Security audit

StartClaw-Optimizer

Security checks for vulnerabilities and agentic risk

Overview

This skill is purpose-aligned overall, but its automation safety controls and context telemetry are under-scoped for the authority it may be given.

Review before installing in workflows that can mutate accounts, files, databases, payments, posts, or authenticated browser sessions. Use it only with idempotent tasks or add cancellation, retry controls, telemetry minimization, and explicit handling for session identifiers before production use.

A.I.G

Vulnerability Patterns

Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally

Findings (2)

T09 · Insecure Skill Coding Practices

Warning

Location: components/scheduler.js:15
Finding: Timed-Out Tasks Continue Running and May Be Retried Concurrently
Content: View full analysis
setTimeout(resolve, backoffMs)); } // Check overall timeout if (Date.now() - startTime > this.timeoutMs) { throw new Error('Task execution timed out'); } } throw new Error(`Task failed after ${this.maxRetries} attempts`); } // Run task with configurable timeout async runWithTimeout(task, context) { return new Promise((resolve, reject) => { const taskPromise = typeof task === 'function' ? task(context) : Promise.resolve(task); const timeoutId = setTimeout(() => { reject(new Error('Task execution timed out')); }, this.timeoutMs); taskPromise .then((result) => { clearTimeout(timeoutId); resolve(result); }) .catch((error) => { clearTimeout(timeoutId); reject(error); }); }); } ``` ### Technical Analysis `runWithTimeout()` implements a timeout by rejecting an outer promise. Rejecting that promise does not cancel the underlying `taskPromise`. JavaScript promi ...[truncated 2421 chars]
Remediation: View remediation

T09 · Insecure Skill Coding Practices

Warning

Location: components/browser-governor.js:39
Finding: Browser Action Queue Does Not Enforce Concurrency Limits or Circuit-Breaker State
Content: View full analysis
{ this.tabQueue.push({ action, resolve, reject }); this.processQueue(); }); } // Process queued browser actions async processQueue() { if (this.browserLocks.size < this.maxConcurrentTabs && this.tabQueue.length > 0) { const queuedAction = this.tabQueue.shift(); try { const result = await queuedAction.action(); queuedAction.resolve(result); } catch (error) { this.browserState.totalErrors++; queuedAction.reject(error); } } } // Circuit breaker for repeated failures isCircuitBreakerTripped() { // Trip circuit breaker if too many errors return this.browserState.totalErrors > 10; } ``` ### Technical Analysis Every call to `queueBrowserAction()` starts a separate asynchronous `processQueue()` invocation. The processor checks `browserLocks.size`, but it does not acquire a lock, increment an active-action counter, or otherwise reserve capacity before executing an action. Consequently, many `processQueue()` calls can independently observe that capacity is available and then start different queued actions. If no external browser locks are held, `browserLocks.size` remains zero regardless of how many queued actions are currently executing. The configured `maxConcurrentTabs` value therefore does not limit action concurrency. The queue processor also handles only one action per invocation rather than running a controlled queue-draining loop. There is no centralized worker state to prevent concurrent drainers. The circuit breaker is similarly non-enforcing. `isCircuitBreakerTripped()` only reports whether more than ten errors have occurred. Neither `q ...[truncated 2058 chars]
Remediation: View remediation

SkillSpector

Vulnerability Patterns

Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep

Findings (1)

Missing User Warnings

Medium

Category: Not specified by scanner
Confidence: 90% confidence
Finding: The README explicitly describes logging compaction events including session keys and context-derived metadata such as token counts and detected key themes, but provides no warning, consent guidance, redaction strategy, or retention limits. Because the feature handles summarized conversational context across sessions and subagents, those logs could capture sensitive user, customer, or proprietary information and create an avoidable privacy and data exposure risk.
Content: No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.