clawtool 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# ClawTool
+
+Local-first diagnose and repair tool for OpenClaw.
+
+## Run
+
+```bash
+npm install
+npm run dev
+```
+
+CLI options:
+
+- `--no-open`: do not auto-open browser
+- `--port <number>`: force a specific port
+
+Example:
+
+```bash
+npm run dev -- --no-open --port 7357
+```
+
+## Build
+
+```bash
+npm run build
+npm start
+```
+
+## Health endpoint
+
+The local server exposes:
+
+- `GET /api/health`
+
+## Current scope (v1 local)
+
+- Local observation only
+- Deterministic local rules
+- Guided fix confirmation before command execution
+- Single-page bilingual UI (zh/en)
+- No cloud API dependency

package/dist/executor.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStep = executeStep;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_os_1 = __importDefault(require("node:os"));
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function executeStep(step, dryRun = false) {
+    if (!step.command) {
+        return { output: '(no command)', skipped: false };
+    }
+    if (dryRun) {
+        return { output: '[dry-run: command not executed]', skipped: false };
+    }
+    try {
+        const { stdout, stderr } = await execAsync(step.command, {
+            timeout: 20000,
+            shell: node_os_1.default.platform() === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env: { ...process.env, PATH: '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:' + (process.env.PATH || '') },
+        });
+        const output = (stdout + (stderr ? '\n' + stderr : '')).trim();
+        return { output: output || '(no output)', skipped: false };
+    }
+    catch (error) {
+        const err = error;
+        const merged = `${err.stdout || ''}${err.stderr || ''}`.trim();
+        return { output: merged || `Error: ${err.message || 'unknown'}`, skipped: false };
+    }
+}

package/dist/index.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_port_1 = __importStar(require("get-port"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const server_1 = require("./server");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === 'darwin'
+        ? `open "${url}"`
+        : platform === 'win32'
+            ? `start "" "${url}"`
+            : `xdg-open "${url}"`;
+    try {
+        await execAsync(cmd);
+    }
+    catch {
+        console.log(`Open browser manually: ${url}`);
+    }
+}
+async function main() {
+    const noOpen = process.argv.includes('--no-open');
+    const portArgIndex = process.argv.indexOf('--port');
+    const requestedPort = portArgIndex > -1 ? Number(process.argv[portArgIndex + 1]) : Number.NaN;
+    const port = Number.isFinite(requestedPort) && requestedPort > 0
+        ? requestedPort
+        : await (0, get_port_1.default)({ port: (0, get_port_1.portNumbers)(7357, 7400) });
+    await (0, server_1.createServer)(port);
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`ClawTool running at ${url}`);
+    if (!noOpen) {
+        await openBrowser(url);
+    }
+}
+main().catch((error) => {
+    console.error('Failed to start ClawTool:', error);
+    process.exit(1);
+});

package/dist/loop.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoctorLoop = void 0;
+const observe_1 = require("./observe");
+const rules_1 = require("./rules");
+const planner_1 = require("./planner");
+const executor_1 = require("./executor");
+const defaultDeps = {
+    collectObservation: observe_1.collectObservation,
+    runRules: rules_1.runRules,
+    buildPlanSteps: planner_1.buildPlanSteps,
+    executeStep: executor_1.executeStep,
+};
+class DoctorLoop {
+    constructor(callback, deps) {
+        this.state = 'idle';
+        this.stopped = false;
+        this.userDescription = '';
+        this.callback = callback;
+        this.deps = { ...defaultDeps, ...deps };
+    }
+    stop() {
+        this.stopped = true;
+    }
+    provideInput(field, value) {
+        if (field === 'userDescription' && this.pendingDescription) {
+            this.pendingDescription(value || '');
+            this.pendingDescription = undefined;
+        }
+    }
+    confirmStep(confirmed) {
+        if (this.pendingConfirm) {
+            this.pendingConfirm(confirmed);
+            this.pendingConfirm = undefined;
+        }
+    }
+    emit(type, data) {
+        this.callback({ type, data });
+    }
+    setState(state) {
+        this.state = state;
+        this.emit('state_change', { state });
+    }
+    async start() {
+        try {
+            const sessionId = Date.now().toString();
+            this.emit('session_start', { sessionId });
+            this.setState('waiting_user_description');
+            this.emit('request_input', {
+                field: 'userDescription',
+                instructions: 'Describe your issue or skip.',
+                allowSkip: true,
+            });
+            this.userDescription = await new Promise((resolve) => {
+                this.pendingDescription = resolve;
+            });
+            if (this.stopped)
+                return;
+            this.setState('observing');
+            this.emit('progress', { message: 'Scanning your local OpenClaw setup...' });
+            const observation = await this.deps.collectObservation();
+            const findings = this.deps.runRules(observation);
+            if (this.stopped)
+                return;
+            const steps = this.deps.buildPlanSteps(findings, observation);
+            this.setState('running');
+            for (let i = 0; i < steps.length; i++) {
+                const step = steps[i];
+                if (this.stopped)
+                    return;
+                if (step.type === 'done') {
+                    const warnings = step.warnings || [];
+                    const fixed = Boolean(step.fixed);
+                    if (fixed)
+                        this.setState('fixed');
+                    else if (warnings.length > 0)
+                        this.setState('degraded');
+                    else
+                        this.setState('healthy');
+                    this.emit('complete', {
+                        fixed,
+                        healthy: !fixed && warnings.length === 0,
+                        degraded: !fixed && warnings.length > 0,
+                        summary: step.summary || 'Completed',
+                        warnings,
+                        problem: step.problem || null,
+                        fix: step.fix || null,
+                    });
+                    return;
+                }
+                this.emit('step_start', { step, index: i });
+                if (step.type === 'fix') {
+                    this.setState('waiting');
+                    this.emit('confirm_needed', { step });
+                    const confirmed = await new Promise((resolve) => {
+                        this.pendingConfirm = resolve;
+                    });
+                    this.setState('running');
+                    if (!confirmed) {
+                        this.emit('step_done', { step, output: '[Skipped by user]', skipped: true, index: i });
+                        continue;
+                    }
+                }
+                const result = await this.deps.executeStep(step);
+                this.emit('step_done', { step, output: result.output, skipped: result.skipped, index: i });
+            }
+            this.setState('not_fixed');
+            this.emit('complete', {
+                fixed: false,
+                healthy: false,
+                degraded: false,
+                summary: 'Plan ended without explicit completion step.',
+                warnings: [],
+            });
+        }
+        catch (error) {
+            this.setState('error');
+            this.emit('error', { message: error.message || 'Unknown error' });
+        }
+    }
+}
+exports.DoctorLoop = DoctorLoop;

package/dist/observe.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+exports.collectObservation = collectObservation;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+async function runCommand(cmd, timeout = 10000) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            timeout,
+            shell: node_os_1.default.platform() === 'win32' ? 'cmd.exe' : '/bin/sh',
+            env: { ...process.env, PATH: '/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:' + (process.env.PATH || '') },
+        });
+        return (stdout + (stderr ? '\n' + stderr : '')).trim() || '(no output)';
+    }
+    catch (error) {
+        const err = error;
+        const merged = `${err.stdout || ''}${err.stderr || ''}`.trim();
+        return merged || `[command failed: ${err.message || 'unknown'}]`;
+    }
+}
+function readFileIfExists(filePath, fallback) {
+    try {
+        return node_fs_1.default.existsSync(filePath) ? node_fs_1.default.readFileSync(filePath, 'utf8') : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function collectObservation(run = runCommand) {
+    const homeDir = node_os_1.default.homedir();
+    const configPath = node_path_1.default.join(homeDir, '.openclaw', 'openclaw.json');
+    const plistPath = node_path_1.default.join(homeDir, 'Library', 'LaunchAgents', 'ai.openclaw.gateway.plist');
+    const logPath = node_path_1.default.join(homeDir, '.openclaw', 'logs', 'gateway.err.log');
+    const openclawVersion = await run('openclaw --version 2>&1');
+    const latestVersion = await run('npm view openclaw version 2>&1');
+    return {
+        timestamp: new Date().toISOString(),
+        openclawStatus: await run('openclaw status 2>&1'),
+        gatewayStatus: await run('openclaw gateway status 2>&1'),
+        gatewayStatusJson: await run('openclaw gateway status --json 2>&1'),
+        configContent: readFileIfExists(configPath, '[config file not found]'),
+        configPath,
+        portCheck: await run('lsof -i :18789 2>&1 || echo "[port not in use]"'),
+        processCheck: await run('ps aux | grep -i "[o]penclaw"'),
+        plistContent: readFileIfExists(plistPath, '[plist not found]'),
+        plistPath,
+        recentLogs: await run(`tail -n 120 ${logPath} 2>&1 || echo "[log unavailable]"`),
+        logPath,
+        nodeVersion: await run('node -v 2>&1'),
+        npmVersion: await run('npm -v 2>&1'),
+        openclawVersion,
+        systemInfo: await run('sw_vers 2>/dev/null || uname -a'),
+        homeDir,
+        officialDoctorOutput: await run('openclaw doctor 2>&1'),
+        desktopAppVersion: await run('defaults read /Applications/OpenClaw.app/Contents/Info.plist CFBundleShortVersionString 2>&1'),
+        desktopAppRunning: await run('pgrep -f "OpenClaw.app" 2>&1'),
+        devicesList: await run('openclaw devices list 2>&1'),
+        sessionIntegrity: await run(`ls ${node_path_1.default.join(homeDir, '.openclaw', 'sessions')} 2>&1 | head -20`),
+        versionGap: `current: ${openclawVersion.trim()} | latest: ${latestVersion.trim()}`,
+        errors: [],
+    };
+}

package/dist/planner.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlanSteps = buildPlanSteps;
+const severityWeight = {
+    critical: 0,
+    high: 1,
+    warning: 2,
+    info: 3,
+};
+function buildPlanSteps(findings) {
+    const sorted = [...findings].sort((a, b) => severityWeight[a.severity] - severityWeight[b.severity]);
+    const steps = [
+        {
+            type: 'read',
+            description: 'Check current gateway status',
+            command: 'openclaw gateway status 2>&1',
+            risk: 'low',
+        },
+    ];
+    for (const finding of sorted) {
+        if (finding.fix) {
+            steps.push({
+                type: 'fix',
+                description: finding.title,
+                command: finding.fix,
+                risk: finding.severity === 'critical' ? 'medium' : 'low',
+            });
+        }
+    }
+    if (sorted.length === 0) {
+        steps.push({
+            type: 'done',
+            description: 'No critical findings',
+            fixed: false,
+            summary: 'No fix was needed. System appears healthy from local checks.',
+            warnings: [],
+            problem: null,
+            fix: null,
+        });
+        return steps;
+    }
+    steps.push({
+        type: 'done',
+        description: 'Plan finished',
+        fixed: true,
+        summary: 'Applied local repair plan based on deterministic findings.',
+        warnings: [],
+        problem: sorted[0]?.description || null,
+        fix: sorted[0]?.fix || null,
+    });
+    return steps;
+}

package/dist/rules.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRules = runRules;
+function runRules(obs) {
+    const findings = [];
+    const gw = (obs.gatewayStatus || '').toLowerCase();
+    if (gw.includes('not running')) {
+        findings.push({
+            id: 'gateway-not-running',
+            severity: 'critical',
+            title: 'Gateway is not running',
+            description: 'OpenClaw gateway is stopped.',
+            fix: 'openclaw gateway start',
+        });
+    }
+    if ((obs.configContent || '').includes('[config file not found]')) {
+        findings.push({
+            id: 'config-missing',
+            severity: 'critical',
+            title: 'Config file missing',
+            description: 'OpenClaw config file is missing.',
+            fix: 'openclaw doctor --yes',
+        });
+    }
+    if (/http_proxy|https_proxy/i.test(obs.plistContent || '')) {
+        findings.push({
+            id: 'proxy-in-plist',
+            severity: 'high',
+            title: 'Proxy set in LaunchAgent plist',
+            description: 'Proxy env vars may break provider connectivity.',
+            fix: 'openclaw gateway restart',
+        });
+    }
+    if (/syntaxerror/i.test(obs.recentLogs || '') && /json5/i.test(obs.recentLogs || '')) {
+        findings.push({
+            id: 'config-json5-error',
+            severity: 'high',
+            title: 'Config parse error detected in logs',
+            description: 'JSON5 syntax errors prevent gateway startup.',
+            fix: 'openclaw doctor --yes',
+        });
+    }
+    return findings;
+}

package/dist/server.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApp = createApp;
+exports.createServer = createServer;
+const express_1 = __importDefault(require("express"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const loop_1 = require("./loop");
+function createApp() {
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json({ limit: '3mb' }));
+    const activeSessions = new Map();
+    app.get('/', (_req, res) => {
+        const htmlPath = node_path_1.default.join(__dirname, '..', 'web', 'index.html');
+        if (!node_fs_1.default.existsSync(htmlPath)) {
+            res.status(404).send('web/index.html not found');
+            return;
+        }
+        res.sendFile(htmlPath);
+    });
+    app.get('/api/diagnose', (req, res) => {
+        const sessionId = Date.now().toString();
+        res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders();
+        const sendEvent = (event) => {
+            const payload = JSON.stringify({ type: event.type, data: event.data, sessionId });
+            res.write(`data: ${payload}\n\n`);
+        };
+        const loop = new loop_1.DoctorLoop((event) => sendEvent(event));
+        activeSessions.set(sessionId, { loop, res });
+        loop.start().catch((error) => {
+            sendEvent({ type: 'error', data: { message: error.message } });
+        });
+        req.on('close', () => {
+            loop.stop();
+            activeSessions.delete(sessionId);
+            try {
+                res.end();
+            }
+            catch {
+                // ignore close race
+            }
+        });
+    });
+    app.post('/api/input', (req, res) => {
+        const { sessionId, field, value } = req.body;
+        if (!sessionId || !field) {
+            res.status(400).json({ error: 'sessionId and field are required' });
+            return;
+        }
+        const session = activeSessions.get(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        session.loop.provideInput(field, value || '');
+        res.json({ ok: true });
+    });
+    app.post('/api/confirm', (req, res) => {
+        const { sessionId, confirmed } = req.body;
+        if (!sessionId || typeof confirmed !== 'boolean') {
+            res.status(400).json({ error: 'sessionId and confirmed are required' });
+            return;
+        }
+        const session = activeSessions.get(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        session.loop.confirmStep(confirmed);
+        res.json({ ok: true });
+    });
+    app.post('/api/fix', (_req, res) => {
+        res.json({ ok: true });
+    });
+    app.get('/api/health', (_req, res) => {
+        res.json({ ok: true, name: 'clawtool', sessions: activeSessions.size });
+    });
+    return app;
+}
+async function createServer(port) {
+    const app = createApp();
+    const server = node_http_1.default.createServer(app);
+    return new Promise((resolve) => {
+        server.listen(port, '127.0.0.1', () => resolve(server));
+    });
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "clawtool",
+  "version": "0.1.0",
+  "description": "Local-first OpenClaw diagnose and repair tool",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "clawtool": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "web",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "openclaw",
+    "diagnostics",
+    "repair",
+    "local"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.21.2",
+    "get-port": "^7.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.23",
+    "@types/node": "^22.13.14",
+    "@types/supertest": "^7.2.0",
+    "supertest": "^7.2.2",
+    "tsx": "^4.20.5",
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.4"
+  }
+}

package/web/index.html

@@ -0,0 +1,268 @@
+<!doctype html>
+<html lang="en" class="notranslate" translate="no">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <meta name="google" content="notranslate" />
+  <title>ClawTool</title>
+  <style>
+    :root {
+      --bg: #f3f5f9;
+      --card: #ffffff;
+      --text: #111827;
+      --muted: #6b7280;
+      --border: #e5e7eb;
+      --blue: #2563eb;
+      --green: #059669;
+      --amber: #d97706;
+      --red: #dc2626;
+      --radius: 14px;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Microsoft YaHei', 'PingFang SC', 'Noto Sans SC', sans-serif;
+      background: radial-gradient(circle at top right, #e0ecff, #f3f5f9 35%);
+      color: var(--text);
+      padding: 24px 12px 64px;
+    }
+    .wrap { max-width: 560px; margin: 0 auto; }
+    .title { text-align: center; margin-bottom: 18px; }
+    .title h1 { margin: 0; font-size: 28px; }
+    .title p { margin: 8px 0 0; color: var(--muted); }
+    .card {
+      background: var(--card);
+      border: 1px solid var(--border);
+      border-radius: var(--radius);
+      padding: 18px;
+      box-shadow: 0 4px 24px rgba(15, 23, 42, .05);
+      margin-bottom: 12px;
+    }
+    .hidden { display: none; }
+    .btn {
+      border: 0;
+      border-radius: 10px;
+      padding: 10px 14px;
+      cursor: pointer;
+      font-weight: 600;
+    }
+    .btn-primary { background: var(--blue); color: #fff; width: 100%; }
+    .btn-ghost { background: #fff; border: 1px solid var(--border); }
+    .btn-ok { background: var(--green); color: #fff; }
+    .btn-skip { background: #fff7ed; color: #9a3412; border: 1px solid #fed7aa; }
+    textarea {
+      width: 100%;
+      min-height: 100px;
+      resize: vertical;
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      padding: 10px;
+      margin-bottom: 10px;
+      font-family: inherit;
+      font-size: 14px;
+    }
+    .row { display: flex; gap: 8px; }
+    .row .btn { flex: 1; }
+    .feed-item { font-size: 14px; line-height: 1.6; }
+    .mono { font-family: ui-monospace, Menlo, Consolas, monospace; font-size: 12px; color: #334155; white-space: pre-wrap; }
+    .badge { display: inline-block; font-size: 11px; padding: 2px 8px; border-radius: 999px; margin-left: 6px; }
+    .b-read { background: #e0e7ff; color: #3730a3; }
+    .b-fix { background: #fef3c7; color: #92400e; }
+    .b-done { background: #dcfce7; color: #166534; }
+    .status { color: var(--muted); font-size: 13px; margin-top: 8px; }
+  </style>
+</head>
+<body>
+  <div class="wrap notranslate">
+    <div class="title">
+      <h1>🦞 ClawTool</h1>
+      <p id="subtitle">Local OpenClaw diagnostics and repair</p>
+    </div>
+
+    <div id="start" class="card">
+      <p id="privacy-text">ClawTool only runs local checks and local commands. Nothing is uploaded.</p>
+      <button id="btn-start" class="btn btn-primary">Start Scan</button>
+    </div>
+
+    <div id="input-card" class="card hidden">
+      <h3 id="input-title">Describe your issue (optional)</h3>
+      <textarea id="input-description" placeholder="Example: gateway not running after upgrade"></textarea>
+      <div class="row">
+        <button id="btn-submit-input" class="btn btn-ok">Continue</button>
+        <button id="btn-skip-input" class="btn btn-ghost">Skip</button>
+      </div>
+    </div>
+
+    <div id="feed" class="hidden"></div>
+  </div>
+
+  <script>
+  (function () {
+    const isZh = /^zh/i.test(navigator.language || '');
+    const T = isZh ? {
+      subtitle: 'OpenClaw 本地诊断与修复',
+      privacy: 'ClawTool 仅在本地读取与执行，不上传数据。',
+      start: '开始扫描',
+      inputTitle: '描述你的问题（可选）',
+      inputPlaceholder: '例如：升级后 gateway 无法启动',
+      continue: '继续',
+      skip: '跳过',
+      waiting: '等待输入...',
+      confirm: '确认执行修复步骤？',
+      allow: '执行',
+      reject: '跳过',
+      done: '已完成',
+      failed: '发生错误'
+    } : {
+      subtitle: 'Local OpenClaw diagnostics and repair',
+      privacy: 'ClawTool only runs local checks and local commands. Nothing is uploaded.',
+      start: 'Start Scan',
+      inputTitle: 'Describe your issue (optional)',
+      inputPlaceholder: 'Example: gateway not running after upgrade',
+      continue: 'Continue',
+      skip: 'Skip',
+      waiting: 'Waiting for input...',
+      confirm: 'Confirm this fix step?',
+      allow: 'Allow',
+      reject: 'Skip',
+      done: 'Completed',
+      failed: 'Error occurred'
+    };
+
+    const el = {
+      subtitle: document.getElementById('subtitle'),
+      privacyText: document.getElementById('privacy-text'),
+      btnStart: document.getElementById('btn-start'),
+      start: document.getElementById('start'),
+      inputCard: document.getElementById('input-card'),
+      inputTitle: document.getElementById('input-title'),
+      inputDescription: document.getElementById('input-description'),
+      btnSubmitInput: document.getElementById('btn-submit-input'),
+      btnSkipInput: document.getElementById('btn-skip-input'),
+      feed: document.getElementById('feed')
+    };
+
+    el.subtitle.textContent = T.subtitle;
+    el.privacyText.textContent = T.privacy;
+    el.btnStart.textContent = T.start;
+    el.inputTitle.textContent = T.inputTitle;
+    el.inputDescription.placeholder = T.inputPlaceholder;
+    el.btnSubmitInput.textContent = T.continue;
+    el.btnSkipInput.textContent = T.skip;
+
+    let sessionId = null;
+    let eventSource = null;
+    let pendingConfirm = null;
+
+    function addCard(html) {
+      const div = document.createElement('div');
+      div.className = 'card feed-item';
+      div.innerHTML = html;
+      el.feed.appendChild(div);
+      return div;
+    }
+
+    async function post(path, body) {
+      await fetch(path, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+      });
+    }
+
+    function connect() {
+      eventSource = new EventSource('/api/diagnose?lang=' + (isZh ? 'zh' : 'en'));
+      eventSource.onmessage = async function (evt) {
+        const payload = JSON.parse(evt.data);
+        const type = payload.type;
+        const data = payload.data || {};
+
+        if (type === 'session_start') {
+          sessionId = payload.sessionId;
+        }
+
+        if (type === 'request_input') {
+          el.inputCard.classList.remove('hidden');
+          addCard('<div class="status">' + T.waiting + '</div>');
+        }
+
+        if (type === 'progress') {
+          addCard('<div>' + (data.message || '') + '</div>');
+        }
+
+        if (type === 'step_start') {
+          const step = data.step || {};
+          const typeBadge = step.type === 'fix' ? 'b-fix' : step.type === 'done' ? 'b-done' : 'b-read';
+          const stepCard = addCard(
+            '<div><strong>' + (step.description || 'step') + '</strong>' +
+            '<span class="badge ' + typeBadge + '">' + (step.type || '') + '</span></div>' +
+            (step.command ? '<div class="mono" translate="no">' + step.command + '</div>' : '')
+          );
+
+          if (step.type === 'fix') {
+            pendingConfirm = step;
+            stepCard.insertAdjacentHTML('beforeend',
+              '<div class="status">' + T.confirm + '</div>' +
+              '<div class="row"><button class="btn btn-ok" data-confirm="yes">' + T.allow + '</button>' +
+              '<button class="btn btn-skip" data-confirm="no">' + T.reject + '</button></div>'
+            );
+          }
+        }
+
+        if (type === 'step_done') {
+          addCard('<div class="mono" translate="no">' + (data.output || '') + '</div>');
+        }
+
+        if (type === 'complete') {
+          addCard('<h3>' + T.done + '</h3><p>' + (data.summary || '') + '</p>');
+          if (eventSource) eventSource.close();
+        }
+
+        if (type === 'error') {
+          addCard('<h3 style="color:var(--red)">' + T.failed + '</h3><p>' + (data.message || '') + '</p>');
+          if (eventSource) eventSource.close();
+        }
+      };
+    }
+
+    el.btnStart.addEventListener('click', function () {
+      el.start.classList.add('hidden');
+      el.feed.classList.remove('hidden');
+      connect();
+    });
+
+    el.btnSubmitInput.addEventListener('click', async function () {
+      if (!sessionId) return;
+      await post('/api/input', {
+        sessionId,
+        field: 'userDescription',
+        value: el.inputDescription.value
+      });
+      el.inputCard.classList.add('hidden');
+    });
+
+    el.btnSkipInput.addEventListener('click', async function () {
+      if (!sessionId) return;
+      await post('/api/input', {
+        sessionId,
+        field: 'userDescription',
+        value: ''
+      });
+      el.inputCard.classList.add('hidden');
+    });
+
+    document.addEventListener('click', async function (event) {
+      const target = event.target;
+      if (!(target instanceof HTMLElement)) return;
+      const choice = target.getAttribute('data-confirm');
+      if (!choice || !sessionId || !pendingConfirm) return;
+      await post('/api/confirm', {
+        sessionId,
+        confirmed: choice === 'yes'
+      });
+      pendingConfirm = null;
+    });
+  })();
+  </script>
+</body>
+</html>