autoclaw 1.3.1 → 1.3.3

package/README.md

@@ -78,7 +78,7 @@ npm install -g autoclaw
 
 ## Quick Start
 
-1.  **Setup**: Run the interactive setup wizard to configure your API keys and integrations.
+1.  **Setup**: Run the interactive setup wizard to configure your API keys and integrations. The wizard runs a live connection test (failures map to the likely wrong field: 401 = key, 404 = base URL, 400 = model name) and can list the provider's models for you to pick from.
     ```bash
     autoclaw setup
     ```
@@ -130,6 +130,29 @@ Unattempted tasks are simply absent from the results file, so `--fail-fast` foll
 
 AutoClaw also keeps its own prompt lean: optional tools (web search, email, group notifications, image generation) only register once their credentials are configured, and in long loops older tool results in the model context are replaced by short excerpts.
 
+### Recipes
+
+Daily ops sweep on Linux (crontab):
+```cron
+0 9 * * * autoclaw batch /opt/ops/daily.jsonl -y -n --resume >> /var/log/autoclaw.log 2>&1
+```
+
+Scheduled sweep on Windows (Task Scheduler):
+```bash
+schtasks /create /tn "AutoClaw Daily" /tr "autoclaw batch C:\ops\daily.jsonl -y -n" /sc daily /st 09:00
+```
+
+Pipeline inside one manifest — each task writes files the next task reads:
+```jsonl
+{"id": "sweep", "task": "检查磁盘与关键服务状态,报告写入 report/sweep.md"}
+{"id": "notify", "task": "读取 report/sweep.md,用三句话总结后推送到飞书"}
+```
+
+Diagnostics on a fresh machine or in CI:
+```bash
+autoclaw doctor   # exit 0 = ready; exit 1 = what's missing is printed
+```
+
 ### Auto-Confirm (CI/CD)
 Automatically approve all tool executions (dangerous, use with caution or in sandboxes).
 ```bash
@@ -141,14 +164,18 @@ autoclaw "Refactor src/index.ts to use ES modules" -y
 - `-P, --provider <name>`: Use a provider preset (see [Providers](#providers)).
 - `-n, --no-interactive`: Exit after processing the initial query (Headless mode).
 - `-y, --yes`: Auto-confirm all tool executions (e.g., shell commands).
+- `--allow-dangerous`: Let `-y` run clearly destructive commands (rm -rf, format, shutdown, ...) that the built-in safety gate would block.
 - `--json`: Emit NDJSON events on stdout (for orchestrators; use with `-n`).
 
+### Diagnostics
+`autoclaw doctor` checks everything headlessly and prints ✓/✗ per item: config files, resolved provider/baseUrl/model, API key, a live connection test, resolved shell, registered tools, and playwright browser status. Exit `0` = ready, `1` = a critical item failed (the failing item is printed). Ideal for CI or a fresh machine.
+
 ### Providers
 AutoClaw works with any OpenAI-compatible endpoint. Built-in presets fill in the base URL and a default model for you:
 ```bash
 autoclaw -P deepseek "Check disk usage and save a report" -y -n
 ```
-Available presets: `openai`, `deepseek`, `moonshot` (Kimi), `dashscope` (Qwen), `zhipu` (GLM), `openrouter`, `ollama` (local). You can still override the model with `-m` or config. When `OPENAI_API_KEY` is not set, the API key is read from the provider's own env var (e.g. `DEEPSEEK_API_KEY`, `MOONSHOT_API_KEY`, `DASHSCOPE_API_KEY`, `ZHIPU_API_KEY`, `OPENROUTER_API_KEY`).
+Available presets: `openai`, `deepseek`, `moonshot` (Kimi), `dashscope` (Qwen), `zhipu` (GLM), `ark` (Volcano Ark), `siliconflow`, `openrouter`, `ollama` (local). You can still override the model with `-m` or config. When `OPENAI_API_KEY` is not set, the API key is read from the provider's own env var (e.g. `DEEPSEEK_API_KEY`, `MOONSHOT_API_KEY`, `DASHSCOPE_API_KEY`, `ZHIPU_API_KEY`, `ARK_API_KEY`, `SILICONFLOW_API_KEY`, `OPENROUTER_API_KEY`).
 
 ## Configuration
 

package/README.zh-CN.md

@@ -79,7 +79,7 @@ npm install -g autoclaw
 
 ## 快速上手
 
-1.  **配置**: 运行交互式设置向导以配置您的 API 密钥和集成插件。
+1.  **配置**: 运行交互式设置向导以配置您的 API 密钥和集成插件。向导会现场做连接测试(失败映射到最可能出错的字段:401=key 错、404=URL 错、400=模型名错),并能拉取服务商的模型列表供你直接选择。
     ```bash
     autoclaw setup
     ```
@@ -131,6 +131,29 @@ autoclaw batch big.jsonl -y -c 4            # 最多 4 个任务并行
 
 AutoClaw 同时会自动给提示词瘦身：可选工具（网页搜索、邮件、群通知、图像生成）只在凭据配置后才会注册进工具定义；长循环中较早的工具结果会被替换为短摘要。
 
+### 实战配方
+
+Linux 定时巡检（crontab）：
+```cron
+0 9 * * * autoclaw batch /opt/ops/daily.jsonl -y -n --resume >> /var/log/autoclaw.log 2>&1
+```
+
+Windows 计划任务：
+```bash
+schtasks /create /tn "AutoClaw Daily" /tr "autoclaw batch C:\ops\daily.jsonl -y -n" /sc daily /st 09:00
+```
+
+一个清单内的流水线——前一个任务写文件,后一个任务读：
+```jsonl
+{"id": "sweep", "task": "检查磁盘与关键服务状态,报告写入 report/sweep.md"}
+{"id": "notify", "task": "读取 report/sweep.md,用三句话总结后推送到飞书"}
+```
+
+新机器或 CI 环境自检：
+```bash
+autoclaw doctor   # 退出 0 = 就绪;退出 1 = 打印缺失项
+```
+
 ### 自动确认 (CI/CD)
 自动批准所有工具执行（危险操作，请谨慎使用或在沙箱环境下运行）。
 ```bash
@@ -142,6 +165,11 @@ autoclaw "将 src/index.ts 重构为使用 ES 模块" -y
 - `-P, --provider <name>`: 使用 provider 预设 (见 [Provider 预设](#provider-预设))。
 - `-n, --no-interactive`: 处理完初始查询后退出 (无头模式)。
 - `-y, --yes`: 自动确认所有工具执行 (例如 Shell 命令)。
+- `--allow-dangerous`: 允许 `-y` 直接执行内置安全闸拦截的明显破坏性命令 (rm -rf、format、shutdown 等)。
+- `--json`: 在 stdout 输出 NDJSON 事件流 (供编排器使用,配合 `-n`)。
+
+### 诊断
+`autoclaw doctor` 无头完成全面自检,逐项打印 ✓/✗:配置文件、解析出的 provider/baseUrl/model、API key、真实连接测试、解析出的 shell、已注册工具、playwright 浏览器状态。退出 `0` = 就绪,`1` = 有关键项失败(会打印是哪项)。适合 CI 或新机器。
 - `--json`: 在 stdout 输出 NDJSON 事件流 (供编排器使用,配合 `-n`)。
 
 ### Provider 预设
@@ -149,7 +177,7 @@ AutoClaw 可对接任意 OpenAI 兼容端点。内置预设可自动填好 Base
 ```bash
 autoclaw -P deepseek "检查磁盘使用情况并保存报告" -y -n
 ```
-可用预设：`openai`、`deepseek`、`moonshot` (Kimi)、`dashscope` (Qwen)、`zhipu` (GLM)、`openrouter`、`ollama` (本地)。模型仍可用 `-m` 或配置覆盖。未设置 `OPENAI_API_KEY` 时，会自动读取各家自己的环境变量 (如 `DEEPSEEK_API_KEY`、`MOONSHOT_API_KEY`、`DASHSCOPE_API_KEY`、`ZHIPU_API_KEY`、`OPENROUTER_API_KEY`)。
+可用预设：`openai`、`deepseek`、`moonshot` (Kimi)、`dashscope` (Qwen)、`zhipu` (GLM)、`ark` (火山方舟)、`siliconflow` (硅基流动)、`openrouter`、`ollama` (本地)。模型仍可用 `-m` 或配置覆盖。未设置 `OPENAI_API_KEY` 时，会自动读取各家自己的环境变量 (如 `DEEPSEEK_API_KEY`、`MOONSHOT_API_KEY`、`DASHSCOPE_API_KEY`、`ZHIPU_API_KEY`、`ARK_API_KEY`、`SILICONFLOW_API_KEY`、`OPENROUTER_API_KEY`)。
 
 ## 配置
 

package/dist/doctor.js

@@ -0,0 +1,81 @@
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import { testConnection } from './setup.js';
+import { getBashPath, resolveShellType } from './shell.js';
+import { getToolDefinitions, listUnavailableTools } from './tools/index.js';
+const require = createRequire(import.meta.url);
+function playwrightBrowserStatus() {
+    try {
+        const { chromium } = require('playwright');
+        const exe = chromium.executablePath();
+        if (exe && fs.existsSync(exe)) {
+            return { ok: true, detail: exe };
+        }
+        return { ok: false, detail: 'playwright installed but no browser downloaded (run: npx playwright install chromium)' };
+    }
+    catch (err) {
+        return { ok: false, detail: `playwright not available (${String(err?.message ?? err).split('\n')[0]})` };
+    }
+}
+function maskKey(key) {
+    if (!key)
+        return 'missing';
+    if (key.length < 8)
+        return '***';
+    return `${key.slice(0, 6)}***${key.slice(-4)}`;
+}
+// Headless self-diagnosis: every check reports ok/critical/detail, so the
+// CLI can render ✓/✗ and derive an exit code without any interaction.
+export async function collectDoctorChecks(cfg) {
+    const checks = [];
+    checks.push({
+        name: 'Global config',
+        ok: cfg.globalExists,
+        critical: true,
+        detail: cfg.globalExists ? cfg.globalFile : `${cfg.globalFile} (missing — run: autoclaw setup)`
+    });
+    checks.push({
+        name: 'Project config',
+        ok: true,
+        critical: false,
+        detail: cfg.projectExists ? cfg.projectFile : '(none)'
+    });
+    checks.push({
+        name: 'API key',
+        ok: !!cfg.apiKey,
+        critical: true,
+        detail: maskKey(cfg.apiKey)
+    });
+    checks.push({
+        name: 'Endpoint',
+        ok: !!cfg.baseUrl,
+        critical: true,
+        detail: `${cfg.providerLabel} | ${cfg.baseUrl || '?'} | model: ${cfg.model}`
+    });
+    if (cfg.apiKey && cfg.baseUrl && cfg.model) {
+        const t = await testConnection(cfg.baseUrl, cfg.apiKey, cfg.model);
+        checks.push({ name: 'Connection', ok: t.ok, critical: true, detail: t.message });
+    }
+    else {
+        checks.push({ name: 'Connection', ok: false, critical: true, detail: 'skipped (key / baseUrl / model missing)' });
+    }
+    const shellType = resolveShellType(cfg.toolConfig);
+    const bashPath = shellType === 'bash' ? getBashPath() : null;
+    checks.push({
+        name: 'Shell',
+        ok: true,
+        critical: false,
+        detail: bashPath ? `${shellType} (${bashPath})` : shellType
+    });
+    const registered = getToolDefinitions(cfg.toolConfig).length;
+    const missing = listUnavailableTools(cfg.toolConfig);
+    checks.push({
+        name: 'Tools',
+        ok: true,
+        critical: false,
+        detail: `${registered} registered${missing.length ? ` (not configured: ${missing.join(', ')})` : ''}`
+    });
+    const pw = playwrightBrowserStatus();
+    checks.push({ name: 'Playwright browsers', ok: pw.ok, critical: false, detail: pw.detail });
+    return checks;
+}

package/dist/index.js

@@ -6,6 +6,8 @@ import dotenv from 'dotenv';
 import { Agent } from './agent.js';
 import { parseManifest, runBatch } from './batch.js';
 import { PROVIDER_PRESETS, providerNames, resolveProvider } from './providers.js';
+import { fetchModelIds, normalizeBaseUrl, testConnection } from './setup.js';
+import { collectDoctorChecks } from './doctor.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -44,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.1';
+let version = '1.3.3';
 try {
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
     version = pkg.version;
@@ -58,9 +60,10 @@ program
     .description('A lightweight AI agent CLI tool')
     .version(version)
     .option('-m, --model <model>', 'Model to use')
-    .option('-P, --provider <name>', 'Use a provider preset (openai, deepseek, moonshot, dashscope, zhipu, openrouter, ollama)')
+    .option('-P, --provider <name>', 'Use a provider preset (openai, deepseek, moonshot, dashscope, zhipu, ark, siliconflow, openrouter, ollama)')
     .option('-n, --no-interactive', 'Exit after processing the initial query (Headless mode)')
     .option('-y, --yes', 'Auto-confirm all tool executions (e.g., shell commands)')
+    .option('--allow-dangerous', 'Let -y run clearly destructive commands (rm -rf, format, shutdown, ...) without the safety block')
     .option('--json', 'Emit NDJSON events on stdout (for orchestrators; use with -n)');
 program
     .command('setup')
@@ -87,6 +90,36 @@ program
     const options = program.opts();
     await runBatchCommand(manifest, options, cmdOptions);
 });
+program
+    .command('doctor')
+    .description('Diagnose configuration and environment (headless)')
+    .action(async () => {
+    const options = program.opts();
+    const { apiKey, baseURL, model, fullConfig } = await resolveRuntime(options, { interactive: false });
+    const providerName = options.provider || process.env.AUTOCLOW_PROVIDER || fullConfig.provider;
+    console.log(chalk.bold.cyan('AutoClaw Doctor 🦞\n'));
+    const checks = await collectDoctorChecks({
+        apiKey,
+        baseUrl: baseURL,
+        model,
+        providerLabel: providerName || 'custom',
+        globalFile: GLOBAL_CONFIG_FILE,
+        projectFile: LOCAL_CONFIG_FILE,
+        globalExists: fs.existsSync(GLOBAL_CONFIG_FILE),
+        projectExists: fs.existsSync(LOCAL_CONFIG_FILE),
+        toolConfig: fullConfig
+    });
+    for (const c of checks) {
+        const mark = c.ok ? chalk.green('✓') : c.critical ? chalk.red('✗') : chalk.yellow('!');
+        console.log(`${mark} ${c.name.padEnd(20)} ${chalk.dim(c.detail)}`);
+    }
+    const failed = checks.filter(c => c.critical && !c.ok);
+    if (failed.length === 0)
+        console.log(chalk.green('\nAll critical checks passed.'));
+    else
+        console.log(chalk.red(`\n${failed.length} critical check(s) failed.`));
+    process.exit(failed.length === 0 ? 0 : 1);
+});
 program.parse(process.argv);
 async function runSetup(options = {}) {
     const isProject = options.project;
@@ -109,7 +142,7 @@ async function runSetup(options = {}) {
     }
     const providerAnswer = await inquirer.prompt([
         {
-            type: 'list',
+            type: 'select',
             name: 'provider',
             message: 'Select your LLM provider:',
             choices: [
@@ -121,34 +154,101 @@ async function runSetup(options = {}) {
     ]);
     const provider = providerAnswer.provider;
     const preset = resolveProvider(provider === 'custom' ? undefined : provider);
-    const answers = await inquirer.prompt([
-        {
-            type: 'password',
-            name: 'apiKey',
-            message: currentConfig.apiKey
-                ? `Enter OpenAI API Key (Leave empty to keep ${maskSecret(currentConfig.apiKey)}):`
-                : 'Enter OpenAI API Key:',
-            mask: '*',
-            validate: (input) => {
-                if (input.length > 0)
-                    return true;
-                if (currentConfig.apiKey)
-                    return true;
-                return 'API Key cannot be empty.';
+    // The connection part (key / Base URL / model) is asked in a loop with a
+    // live test, so typos never make it into the saved config.
+    const askConnection = async () => {
+        const defaults = {
+            apiKey: currentConfig.apiKey,
+            baseUrl: currentConfig.baseUrl || preset?.baseUrl || 'https://api.openai.com/v1',
+            model: currentConfig.model || preset?.defaultModel || 'gpt-5.6'
+        };
+        const core = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: defaults.apiKey
+                    ? `Enter API Key (Leave empty to keep ${maskSecret(defaults.apiKey)}):`
+                    : `Enter API Key${preset?.apiKeyEnv ? ` (or set ${preset.apiKeyEnv} in your environment)` : ''}:`,
+                mask: '*',
+                validate: (input) => {
+                    if (input.length > 0)
+                        return true;
+                    if (defaults.apiKey)
+                        return true;
+                    return 'API Key cannot be empty.';
+                }
+            },
+            {
+                type: 'input',
+                name: 'baseUrl',
+                message: 'Enter API Base URL:',
+                default: defaults.baseUrl
             }
-        },
-        {
-            type: 'input',
-            name: 'baseUrl',
-            message: 'Enter API Base URL:',
-            default: currentConfig.baseUrl || preset?.baseUrl || 'https://api.openai.com/v1'
-        },
-        {
-            type: 'input',
-            name: 'model',
-            message: 'Enter default Model:',
-            default: currentConfig.model || preset?.defaultModel || 'gpt-5.6'
-        },
+        ]);
+        const apiKey = core.apiKey || defaults.apiKey || '';
+        const baseUrl = normalizeBaseUrl(core.baseUrl || defaults.baseUrl);
+        // Prefer the provider's own catalog over guessing model names.
+        console.log(chalk.dim('Fetching available models...'));
+        const ids = await fetchModelIds(baseUrl, apiKey);
+        let model;
+        if (ids) {
+            console.log(chalk.dim(`Found ${ids.length} models.`));
+            const picked = await inquirer.prompt([
+                {
+                    type: 'select',
+                    name: 'model',
+                    message: 'Select default Model:',
+                    choices: [{ name: '✎ Enter manually', value: '__manual__' }, ...ids.map(id => ({ name: id, value: id }))],
+                    default: ids.includes(defaults.model) ? defaults.model : undefined,
+                    pageSize: 12
+                }
+            ]);
+            if (picked.model === '__manual__') {
+                const manual = await inquirer.prompt([
+                    { type: 'input', name: 'model', message: 'Enter default Model:', default: defaults.model }
+                ]);
+                model = manual.model;
+            }
+            else {
+                model = picked.model;
+            }
+        }
+        else {
+            const manual = await inquirer.prompt([
+                { type: 'input', name: 'model', message: 'Enter default Model (catalog unavailable):', default: defaults.model }
+            ]);
+            model = manual.model;
+        }
+        return { apiKey, baseUrl, model };
+    };
+    let connection = await askConnection();
+    console.log(chalk.dim('Running connection test (sends one tiny prompt — normal provider billing applies)...'));
+    let test = await testConnection(connection.baseUrl, connection.apiKey, connection.model);
+    while (!test.ok) {
+        console.log(chalk.red(`\n✗ ${test.message}`));
+        const next = await inquirer.prompt([
+            {
+                type: 'select',
+                name: 'action',
+                message: 'Connection test failed. What next?',
+                choices: [
+                    { name: 'Re-enter API key / Base URL / model', value: 'edit' },
+                    { name: 'Test again', value: 'retry' },
+                    { name: 'Save anyway (e.g. the provider is temporarily down)', value: 'save' }
+                ],
+                default: 'edit'
+            }
+        ]);
+        if (next.action === 'save')
+            break;
+        if (next.action === 'edit')
+            connection = await askConnection();
+        console.log(chalk.dim('Running connection test...'));
+        test = await testConnection(connection.baseUrl, connection.apiKey, connection.model);
+    }
+    if (test.ok)
+        console.log(chalk.green('✓ Connection test passed.'));
+    const answers = await inquirer.prompt([
         {
             type: 'confirm',
             name: 'configureImage',
@@ -183,7 +283,7 @@ async function runSetup(options = {}) {
         }
     ]);
     // Resolve sensitive values (Keep old if empty)
-    const finalApiKey = answers.apiKey || currentConfig.apiKey;
+    const finalApiKey = connection.apiKey || currentConfig.apiKey;
     let imageConfig = {
         imageApiKey: currentConfig.imageApiKey,
         imageBaseUrl: currentConfig.imageBaseUrl,
@@ -346,8 +446,8 @@ async function runSetup(options = {}) {
     }
     const newConfig = {
         apiKey: finalApiKey,
-        baseUrl: answers.baseUrl,
-        model: answers.model,
+        baseUrl: connection.baseUrl,
+        model: connection.model,
         provider: provider === 'custom' ? undefined : provider,
         ...imageConfig,
         ...emailConfig,
@@ -360,6 +460,8 @@ async function runSetup(options = {}) {
         }
         fs.writeFileSync(targetFile, JSON.stringify(newConfig, null, 2), { mode: 0o600 });
         console.log(chalk.green(`\n✅ Configuration saved to ${targetFile}`));
+        console.log(chalk.dim(`   provider: ${provider === 'custom' ? 'custom' : provider}  |  baseUrl: ${connection.baseUrl}  |  model: ${connection.model}`));
+        console.log(chalk.dim(`   connection test: ${test.ok ? 'passed ✓' : 'skipped (saved without a passing test)'}`));
         console.log(chalk.cyan("You can now run 'autoclaw' to start using the agent."));
     }
     catch (error) {
@@ -368,7 +470,9 @@ async function runSetup(options = {}) {
 }
 // Shared by `chat` and `batch`: resolve credentials, endpoints and runtime
 // flags from CLI args > env > project config > global config > provider preset.
-async function resolveRuntime(options) {
+// With interactive: false (doctor), a missing key resolves to '' instead of
+// prompting, so the caller can report it.
+async function resolveRuntime(options, opts = {}) {
     // 1. Load Global JSON
     const globalConfig = loadJsonConfig(GLOBAL_CONFIG_FILE);
     // 2. Load Local JSON (Project Level)
@@ -391,6 +495,7 @@ async function resolveRuntime(options) {
     let model = options.model || process.env.OPENAI_MODEL || fullConfig.model || preset?.defaultModel || 'gpt-5.6';
     // Inject Runtime Flags
     fullConfig.autoConfirm = options.yes;
+    fullConfig.allowDangerous = !!options.allowDangerous;
     fullConfig.jsonMode = !!options.json;
     // Usage tracking is opt-in: not every OpenAI-compatible provider accepts
     // stream_options.include_usage, so never force it on.
@@ -422,6 +527,9 @@ async function resolveRuntime(options) {
     if (process.env.WECOM_KEYWORD)
         fullConfig.wecomKeyword = process.env.WECOM_KEYWORD;
     if (!apiKey) {
+        if (opts.interactive === false) {
+            return { apiKey: '', baseURL, model, fullConfig };
+        }
         console.log(chalk.yellow("API Key not found."));
         const { doSetup } = await inquirer.prompt([
             {

package/dist/providers.js

@@ -29,6 +29,18 @@ export const PROVIDER_PRESETS = {
         defaultModel: 'glm-5',
         apiKeyEnv: 'ZHIPU_API_KEY'
     },
+    ark: {
+        label: 'Volcano Ark (Doubao/DeepSeek)',
+        baseUrl: 'https://ark.cn-beijing.volces.com/api/v3',
+        defaultModel: 'deepseek-v4-flash',
+        apiKeyEnv: 'ARK_API_KEY'
+    },
+    siliconflow: {
+        label: 'SiliconFlow',
+        baseUrl: 'https://api.siliconflow.cn/v1',
+        defaultModel: 'deepseek-ai/DeepSeek-V4',
+        apiKeyEnv: 'SILICONFLOW_API_KEY'
+    },
     openrouter: {
         label: 'OpenRouter',
         baseUrl: 'https://openrouter.ai/api/v1',

package/dist/setup.js

@@ -0,0 +1,61 @@
+// Pure helpers behind the setup wizard: URL normalization, a live
+// connection test with actionable error mapping, and provider model
+// catalog fetching. Kept free of inquirer so they are unit-testable.
+export function normalizeBaseUrl(url) {
+    let u = String(url ?? '').trim();
+    if (u && !/^https?:\/\//i.test(u))
+        u = `https://${u}`;
+    return u.replace(/\/+$/, '');
+}
+// Sends one tiny real prompt through the exact endpoint the user
+// configured, and maps failures to the field that is most likely wrong.
+export async function testConnection(baseUrl, apiKey, model) {
+    const url = `${normalizeBaseUrl(baseUrl)}/chat/completions`;
+    let resp;
+    try {
+        resp = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+            body: JSON.stringify({ model, messages: [{ role: 'user', content: 'ping' }], stream: false }),
+            signal: AbortSignal.timeout(15000)
+        });
+    }
+    catch (err) {
+        return { ok: false, kind: 'network', message: `Cannot reach ${url} (${err?.message ?? err}). Check the Base URL and your network.` };
+    }
+    if (resp.ok) {
+        return { ok: true, kind: 'ok', message: `Connection OK — ${model} responded.` };
+    }
+    const detail = (await resp.text().catch(() => '')).slice(0, 300);
+    if (resp.status === 401 || resp.status === 403) {
+        return { ok: false, kind: 'auth', message: `API key rejected (${resp.status}). Double-check the key. ${detail}` };
+    }
+    if (resp.status === 404) {
+        return { ok: false, kind: 'not-found', message: `Endpoint not found (404). The Base URL is likely wrong. ${detail}` };
+    }
+    if (resp.status === 400) {
+        return { ok: false, kind: 'model', message: `Request rejected (400). The model name "${model}" is likely wrong for this endpoint. ${detail}` };
+    }
+    return { ok: false, kind: 'server', message: `Provider returned ${resp.status}. ${detail}` };
+}
+// Returns the provider's model IDs (sorted) or null when the endpoint does
+// not offer a catalog — the wizard then falls back to manual entry.
+export async function fetchModelIds(baseUrl, apiKey) {
+    try {
+        const resp = await fetch(`${normalizeBaseUrl(baseUrl)}/models`, {
+            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+            signal: AbortSignal.timeout(15000)
+        });
+        if (!resp.ok)
+            return null;
+        const data = await resp.json();
+        const ids = (Array.isArray(data?.data) ? data.data : [])
+            .map((m) => m?.id)
+            .filter((id) => typeof id === 'string' && id.length > 0);
+        ids.sort();
+        return ids.length > 0 ? ids : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/core.js

@@ -5,6 +5,28 @@ import chalk from 'chalk';
 import { execShellCommand } from '../shell.js';
 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;
+// the agent-level truncation in truncate.ts applies on top of this.
+const READ_FILE_MAX_BYTES = 1024 * 1024;
+// Even with -y, an unattended agent must not execute clearly destructive
+// commands — a poisoned tool result (e.g. prompt injection via a web page)
+// would otherwise reach the shell directly. Matched commands are refused
+// with a message the model can act on; --allow-dangerous overrides.
+export const DANGEROUS_PATTERNS = [
+    { re: /\brm\s+(?:-\w+\s+)*-\w*[rR]\w*[fF]\b/, label: 'rm with recursive+force' },
+    { re: /\b(?:rd|rmdir|del|erase)\s+\/[sS]\b/, label: 'Windows recursive delete (rd/del /s)' },
+    { re: /\bRemove-Item\b[^;\n]*-(?:Recurse[^;\n]*Force|Force[^;\n]*Recurse)/i, label: 'PowerShell Remove-Item -Recurse -Force' },
+    { re: /\b(?:format|diskpart)\b/i, label: 'disk format / diskpart' },
+    { re: /\bmkfs(?:\.\w+)?\b/i, label: 'mkfs' },
+    { re: /\bdd\b[^|]*\bof=/i, label: 'dd raw write' },
+    { re: /(?:>>?|tee)\s*\/dev\/(?:sd|nvme|hd|vd)[a-z]/i, label: 'write to block device' },
+    { re: /\b(?:shutdown|reboot|halt|poweroff)\b/i, label: 'host power control' },
+    { re: /\breg\s+delete\b/i, label: 'registry delete' }
+];
+export function matchDangerousPattern(command) {
+    const hit = DANGEROUS_PATTERNS.find(p => p.re.test(command));
+    return hit ? hit.label : null;
+}
 export const ShellTool = {
     name: "Shell Execution",
     definition: {
@@ -25,6 +47,14 @@ export const ShellTool = {
     handler: async (args, config) => {
         console.log(chalk.yellow(`\nAI wants to execute: `) + chalk.bold(args.command));
         console.log(chalk.dim(`Reason: ${args.rationale}`));
+        // Safety gate runs first: blocked commands are refused even with --yes.
+        if (!config?.allowDangerous) {
+            const label = matchDangerousPattern(args.command);
+            if (label) {
+                console.log(chalk.red(`\n[blocked] ${label}`));
+                return `Error: command blocked by AutoClaw safety policy (matched: ${label}). It was NOT executed. If this task genuinely requires it, the user must restart AutoClaw with --allow-dangerous; otherwise find a safer way to achieve the same goal.`;
+            }
+        }
         const timeoutMs = Number(config?.shellTimeout || process.env.AUTOCLOW_SHELL_TIMEOUT || DEFAULT_SHELL_TIMEOUT_MS);
         // Check for auto-confirm flag
         if (!config?.autoConfirm) {
@@ -78,13 +108,30 @@ export const ReadFileTool = {
         }
     },
     handler: async (args) => {
+        let fh;
         try {
-            const content = await fs.readFile(args.path, 'utf-8');
+            fh = await fs.open(args.path, 'r');
+            const buf = Buffer.alloc(READ_FILE_MAX_BYTES);
+            const { bytesRead } = await fh.read(buf, 0, READ_FILE_MAX_BYTES, 0);
+            const slice = buf.subarray(0, bytesRead);
+            // NUL bytes are the reliable tell for binary content; returning them
+            // as "utf-8" would only hand the model mojibake.
+            if (slice.includes(0)) {
+                return `Error: ${args.path} looks like a binary file (${bytesRead} bytes read). Inspect it with execute_shell_command instead (e.g. strings, xxd, file).`;
+            }
+            const content = slice.toString('utf-8');
+            if (bytesRead === READ_FILE_MAX_BYTES) {
+                const { size } = await fh.stat();
+                return `${content}\n[AutoClaw] File truncated at ${READ_FILE_MAX_BYTES} bytes (file is ${size} bytes). Use execute_shell_command to read specific ranges.`;
+            }
             return content;
         }
         catch (error) {
             return `Error reading file: ${error.message}`;
         }
+        finally {
+            await fh?.close();
+        }
     }
 };
 export const WriteFileTool = {

package/dist/tools/email.js

@@ -34,6 +34,9 @@ export const EmailTool = {
                 host: config.smtpHost,
                 port: parseInt(config.smtpPort || '587'),
                 secure: parseInt(config.smtpPort) === 465, // true for 465, false for other ports
+                connectionTimeout: 30000,
+                greetingTimeout: 30000,
+                socketTimeout: 120000,
                 auth: {
                     user: config.smtpUser,
                     pass: config.smtpPass,

package/dist/tools/image.js

@@ -64,7 +64,7 @@ const toolDefinition = {
     }
 };
 async function downloadImage(url, destPath) {
-    const response = await fetch(url);
+    const response = await fetch(url, { signal: AbortSignal.timeout(120000) });
     if (!response.ok)
         throw new Error(`Failed to download image: ${response.statusText}`);
     const buffer = await response.arrayBuffer();

package/dist/tools/notify.js

@@ -80,7 +80,8 @@ export const NotifyTool = {
             const response = await fetch(webhookUrl, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(payload)
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(30000)
             });
             const result = await response.json();
             // Platform specific success checks

package/dist/tools/search.js

@@ -42,7 +42,8 @@ export const SearchTool = {
                     include_answer: true,
                     include_images: false,
                     max_results: 5
-                })
+                }),
+                signal: AbortSignal.timeout(30000)
             });
             if (!response.ok) {
                 const errText = await response.text();

package/package.json

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