autoclaw 1.3.3 → 1.3.4

package/README.md

@@ -194,6 +194,7 @@ AutoClaw uses a hierarchical configuration system.
 - `model`: Default model to use.
 - `maxSteps`: Max LLM turns per task before the agent stops (default: `25`).
 - `shellTimeout`: Shell command timeout in milliseconds (default: `120000`).
+- `taskTimeoutMs`: Whole-task wall-clock timeout in milliseconds (off by default; aborts in-flight API calls and stops with `timeout` status).
 - `shell`: Force a shell for `execute_shell_command` (`bash`, `powershell`, `cmd`, `sh`; default: auto-detect — Git Bash > PowerShell > cmd on Windows).
 - `tavilyApiKey`: API Key for Tavily Web Search.
 - `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP Email settings.
@@ -214,6 +215,7 @@ Create a file at `.autoclaw/setting.json`:
 - `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`: main LLM settings.
 - `AUTOCLOW_PROVIDER`: provider preset used when `-P` is not passed.
 - `AUTOCLOW_MAX_STEPS`, `AUTOCLOW_SHELL_TIMEOUT`: reliability limits (max LLM turns per task; shell timeout in ms).
+- `AUTOCLOW_TASK_TIMEOUT_MS`: whole-task wall-clock timeout in ms.
 - `AUTOCLOW_SHELL`: force the shell for shell commands (`bash`, `powershell`, `cmd`, `sh`).
 - `AUTOCLOW_INCLUDE_USAGE`: set to `1`/`true` to request token usage from the API (opt-in).
 - `TAVILY_API_KEY`, `SMTP_HOST`/`SMTP_PORT`/`SMTP_USER`/`SMTP_PASS`, `FEISHU_WEBHOOK`/`FEISHU_KEYWORD`, `DINGTALK_WEBHOOK`/`DINGTALK_KEYWORD`, `WECOM_WEBHOOK`/`WECOM_KEYWORD`: tool credentials as an alternative to setup.

package/README.zh-CN.md

@@ -196,6 +196,7 @@ AutoClaw 使用层级配置系统。
 - `model`: 默认使用的模型。
 - `maxSteps`: 单任务最大 LLM 轮数，超出后自动停止 (默认: `25`)。
 - `shellTimeout`: Shell 命令超时时间（毫秒）(默认: `120000`)。
+- `taskTimeoutMs`: 单任务整体墙钟超时（毫秒，默认关闭；会中断进行中的 API 调用并以 `timeout` 状态停止）。
 - `shell`: 强制 `execute_shell_command` 使用的 shell (`bash`、`powershell`、`cmd`、`sh`；默认自动检测——Windows 上优先 Git Bash > PowerShell > cmd)。
 - `tavilyApiKey`: Tavily 网页搜索的 API 密钥。
 - `smtpHost`, `smtpPort`, `smtpUser`, `smtpPass`, `smtpFrom`: SMTP 邮件设置。
@@ -216,6 +217,7 @@ AutoClaw 使用层级配置系统。
 - `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`: 主模型设置。
 - `AUTOCLOW_PROVIDER`: 未传 `-P` 时使用的 provider 预设。
 - `AUTOCLOW_MAX_STEPS`, `AUTOCLOW_SHELL_TIMEOUT`: 稳定性限制（单任务最大轮数；Shell 超时毫秒数）。
+- `AUTOCLOW_TASK_TIMEOUT_MS`: 单任务整体墙钟超时（毫秒）。
 - `AUTOCLOW_SHELL`: 强制 shell 命令使用的 shell (`bash`、`powershell`、`cmd`、`sh`)。
 - `AUTOCLOW_INCLUDE_USAGE`: 设为 `1`/`true` 时向 API 请求 token 用量（可选开启）。
 - `TAVILY_API_KEY`, `SMTP_HOST`/`SMTP_PORT`/`SMTP_USER`/`SMTP_PASS`, `FEISHU_WEBHOOK`/`FEISHU_KEYWORD`, `DINGTALK_WEBHOOK`/`DINGTALK_KEYWORD`, `WECOM_WEBHOOK`/`WECOM_KEYWORD`: 工具凭据，可作为 setup 的替代方式。

package/dist/agent.js

@@ -104,6 +104,13 @@ RULES OF ENGAGEMENT:
     async chat(userInput) {
         this.messages.push({ role: "user", content: userInput });
         const maxSteps = Number(this.config?.maxSteps || process.env.AUTOCLOW_MAX_STEPS || DEFAULT_MAX_STEPS);
+        const taskTimeoutMs = Number(this.config?.taskTimeoutMs || process.env.AUTOCLOW_TASK_TIMEOUT_MS || 0);
+        const deadline = taskTimeoutMs > 0 ? Date.now() + taskTimeoutMs : Number.POSITIVE_INFINITY;
+        const abortController = new AbortController();
+        const abortTimer = taskTimeoutMs > 0
+            ? setTimeout(() => abortController.abort(new Error(`task wall-clock timeout after ${taskTimeoutMs}ms`)), taskTimeoutMs)
+            : null;
+        const startedAt = Date.now();
         let active = true;
         let step = 0;
         let status = 'completed';
@@ -120,6 +127,13 @@ RULES OF ENGAGEMENT:
                 }
                 break;
             }
+            if (Date.now() > deadline) {
+                status = 'timeout';
+                if (!this.jsonMode) {
+                    console.log(chalk.yellow(`\n[TaskTimeout] Wall-clock limit of ${taskTimeoutMs}ms reached; stopping.`));
+                }
+                break;
+            }
             this.trimOldToolResults();
             step++;
             const spinner = this.jsonMode
@@ -133,13 +147,13 @@ RULES OF ENGAGEMENT:
                 stream = await withRetry(async () => this.client.chat.completions.create({
                     model: this.model,
                     messages: this.messages,
-                    tools: getToolDefinitions(),
+                    tools: getToolDefinitions(this.config),
                     tool_choice: "auto",
                     stream: true,
                     // Not every OpenAI-compatible provider accepts stream_options;
                     // usage tracking is therefore opt-in only.
                     ...(this.config?.includeUsage ? { stream_options: { include_usage: true } } : {})
-                }), {
+                }, { signal: abortController.signal }), {
                     onRetry: (err, nextAttempt, delayMs) => {
                         spinner.text = `API error (${err.message}); retrying in ${Math.round(delayMs / 1000)}s (attempt ${nextAttempt})...`;
                     }
@@ -149,8 +163,14 @@ RULES OF ENGAGEMENT:
                 spinner.fail('Error during processing');
                 if (!this.jsonMode)
                     console.error(chalk.red(error.message));
-                status = 'error';
-                errorMessage = error.message;
+                if (abortController.signal.aborted) {
+                    status = 'timeout';
+                    errorMessage = `task wall-clock timeout after ${taskTimeoutMs}ms`;
+                }
+                else {
+                    status = 'error';
+                    errorMessage = error.message;
+                }
                 active = false;
                 break;
             }
@@ -231,8 +251,14 @@ RULES OF ENGAGEMENT:
                 spinner.fail('Error during processing');
                 if (!this.jsonMode)
                     console.error(chalk.red(error.message));
-                status = 'error';
-                errorMessage = error.message;
+                if (abortController.signal.aborted) {
+                    status = 'timeout';
+                    errorMessage = `task wall-clock timeout after ${taskTimeoutMs}ms`;
+                }
+                else {
+                    status = 'error';
+                    errorMessage = error.message;
+                }
                 active = false;
                 break;
             }
@@ -351,6 +377,8 @@ RULES OF ENGAGEMENT:
                 this.emitEvent({ event: 'usage', step, ...totalUsage });
             }
         }
+        if (abortTimer)
+            clearTimeout(abortTimer);
         const result = {
             status,
             steps: step,
@@ -358,9 +386,33 @@ RULES OF ENGAGEMENT:
             ...(errorMessage ? { error: errorMessage } : {}),
             ...(sawUsage ? { usage: totalUsage } : {})
         };
+        this.appendRunLog(userInput, result, startedAt);
         this.emitEvent({ event: 'run_end', ...result });
         return result;
     }
+    // Best-effort local run history: ~/.autoclaw/logs/runs.jsonl, one line
+    // per run, for post-hoc debugging of unattended batches. Logging must
+    // never fail a run.
+    appendRunLog(userInput, result, startedAt) {
+        try {
+            const dir = path.join(os.homedir(), '.autoclaw', 'logs');
+            fs.mkdirSync(dir, { recursive: true });
+            const line = JSON.stringify({
+                time: new Date().toISOString(),
+                model: this.model,
+                task: String(userInput).slice(0, 200),
+                status: result.status,
+                steps: result.steps,
+                ...(result.error ? { error: result.error.slice(0, 300) } : {}),
+                ...(result.usage ? { usage: result.usage } : {}),
+                durationMs: Date.now() - startedAt
+            });
+            fs.appendFileSync(path.join(dir, 'runs.jsonl'), line + '\n');
+        }
+        catch {
+            // ignore
+        }
+    }
     // Every turn resends the full history, so early large tool results
     // dominate context growth. Keep the most recent results intact and bound
     // older ones to a short excerpt (full output stays on disk via /view when

package/dist/batch.js

@@ -25,6 +25,8 @@ export function parseManifest(raw) {
         const entry = { lineNo, id, task: parsed.task.trim() };
         if (typeof parsed.maxSteps === 'number' && parsed.maxSteps > 0)
             entry.maxSteps = parsed.maxSteps;
+        if (typeof parsed.taskTimeoutMs === 'number' && parsed.taskTimeoutMs > 0)
+            entry.taskTimeoutMs = parsed.taskTimeoutMs;
         if (typeof parsed.model === 'string' && parsed.model.trim())
             entry.model = parsed.model.trim();
         if (typeof parsed.provider === 'string' && parsed.provider.trim())

package/dist/index.js

@@ -46,7 +46,7 @@ dotenv.config({ path: GLOBAL_ENV_FILE });
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // In dist/index.js, package.json is usually up one level in the root
 const pkgPath = path.join(__dirname, '..', 'package.json');
-let version = '1.3.3';
+let version = '1.3.4';
 try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     version = pkg.version;
@@ -615,7 +615,8 @@ async function runBatchCommand(manifestPath, globalOptions, cmdOptions) {
             ...fullConfig,
             // The results file is the machine-readable contract in batch mode.
             jsonMode: false,
-            maxSteps: entry.maxSteps ?? fullConfig.maxSteps
+            maxSteps: entry.maxSteps ?? fullConfig.maxSteps,
+            taskTimeoutMs: entry.taskTimeoutMs ?? fullConfig.taskTimeoutMs
         };
         const agent = new Agent(apiKey, taskBaseURL, taskModel, taskConfig);
         const start = Date.now();
@@ -667,9 +668,9 @@ async function runChat(queryParts, options) {
         }
         const result = await agent.chat(initialQuery);
         // Headless mode exit — the exit code is the orchestrator-facing outcome:
-        // 0 completed, 1 hard failure, 2 step cap reached (task unfinished).
+        // 0 completed, 1 hard failure, 2 unfinished (step cap or wall-clock timeout).
         if (!options.interactive) {
-            process.exit(result.status === 'completed' ? 0 : result.status === 'max_steps' ? 2 : 1);
+            process.exit(result.status === 'completed' ? 0 : result.status === 'max_steps' || result.status === 'timeout' ? 2 : 1);
         }
     }
     // Main chat loop

package/dist/tools/core.js

@@ -3,6 +3,7 @@ import * as path from 'path';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { execShellCommand } from '../shell.js';
+import * as os from 'os';
 const DEFAULT_SHELL_TIMEOUT_MS = 120000;
 const SHELL_MAX_BUFFER = 10 * 1024 * 1024;
 // Bounded reads keep a huge file from exhausting memory or the model context;
@@ -27,6 +28,24 @@ export function matchDangerousPattern(command) {
     const hit = DANGEROUS_PATTERNS.find(p => p.re.test(command));
     return hit ? hit.label : null;
 }
+// An unattended agent reads web pages and repos; a prompt injection must not
+// end up reading AutoClaw's own credential stores (or classic .env files)
+// and exfiltrating them. Blocked for read_file/write_file unless
+// --allow-dangerous. execute_shell_command is not pattern-restricted here.
+export function isSensitivePath(p) {
+    const norm = path.normalize(String(p)).toLowerCase();
+    const protectedFiles = [
+        path.join(os.homedir(), '.autoclaw', 'setting.json').toLowerCase(),
+        path.join(os.homedir(), '.autoclaw', '.env').toLowerCase(),
+        path.join(process.cwd(), '.autoclaw', 'setting.json').toLowerCase()
+    ];
+    if (protectedFiles.includes(norm))
+        return true;
+    return path.basename(norm).startsWith('.env');
+}
+function sensitivePathBlock(p, verb) {
+    return `Error: ${p} is blocked by AutoClaw safety policy (credential/secret store). It was NOT ${verb === 'read' ? 'read' : 'written'}. If this task genuinely requires it, restart AutoClaw with --allow-dangerous.`;
+}
 export const ShellTool = {
     name: "Shell Execution",
     definition: {
@@ -107,7 +126,10 @@ export const ReadFileTool = {
             }
         }
     },
-    handler: async (args) => {
+    handler: async (args, config) => {
+        if (!config?.allowDangerous && isSensitivePath(args.path)) {
+            return sensitivePathBlock(args.path, 'read');
+        }
         let fh;
         try {
             fh = await fs.open(args.path, 'r');
@@ -151,7 +173,10 @@ export const WriteFileTool = {
             }
         }
     },
-    handler: async (args) => {
+    handler: async (args, config) => {
+        if (!config?.allowDangerous && isSensitivePath(args.path)) {
+            return sensitivePathBlock(args.path, 'write');
+        }
         try {
             await fs.mkdir(path.dirname(args.path), { recursive: true });
             await fs.writeFile(args.path, args.content, 'utf-8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoclaw",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "type": "module",
   "main": "dist/index.js",
   "bin": {