s-app-scoder-agent 0.9.2 → 0.9.6

package/dist/tools/read-file.js

@@ -0,0 +1,64 @@
+import { readFileSync, statSync, realpathSync } from "node:fs";
+import { relative } from "node:path";
+import { detectImageBytes } from "../media/image.js";
+import { clamp, MAX_FILE_SIZE_BYTES, safePath, toPosInt, toResult } from "./path-safety.js";
+import { isProtectedEnvFile } from "./path-safety.js";
+export function toolReadFile(workdir, args) {
+    return toResult(() => {
+        const abs = safePath(workdir, args.path);
+        // H-04: .env read policy — ask trước khi trả nội dung (secrets hygiene).
+        const rel = relative(workdir, abs);
+        let policyPath = rel;
+        try {
+            policyPath = relative(workdir, realpathSync(abs));
+        }
+        catch { /* handled by safePath */ }
+        const envPolicy = isProtectedEnvFile(policyPath.toLowerCase());
+        if (envPolicy === "ask") {
+            return {
+                ok: false,
+                output: `ASK_PERMISSION: ${rel} may contain secrets (env file). ` +
+                    `Ask the user to confirm before reading; suggest reading .env.example instead ` +
+                    `or running with a permission rule ({"action":"shell","resource":"read .env","effect":"allow"}).`,
+            };
+        }
+        const st = statSync(abs);
+        if (st.isDirectory()) {
+            return { ok: false, output: `ERROR: ${args.path} is a directory — use list_files instead.` };
+        }
+        if (st.size > MAX_FILE_SIZE_BYTES) {
+            return {
+                ok: false,
+                output: `ERROR: ${args.path} is ${(st.size / 1024 / 1024).toFixed(1)}MB (limit ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB). Use run_command with grep/head/tail to inspect specific parts.`,
+            };
+        }
+        // T7: image file → base64 notice cho TUI render (LLM vẫn nhận mô tả text).
+        let image;
+        try {
+            const probe = readFileSync(abs);
+            const ext = detectImageBytes(probe);
+            if (ext)
+                image = `data:image/${ext};base64,${probe.toString("base64")}`;
+        }
+        catch {
+            // not an image / unreadable — fall through to text read
+        }
+        if (image) {
+            return { ok: true, output: `[image: ${args.path}]`, image };
+        }
+        if (statSync(abs).size > MAX_FILE_SIZE_BYTES) {
+            return { ok: false, output: `ERROR: ${args.path} exceeds the ${MAX_FILE_SIZE_BYTES / 1024 / 1024}MB edit limit.` };
+        }
+        const content = readFileSync(abs, "utf8");
+        const lines = content.split("\n");
+        const total = lines.length;
+        // v2: line-range reads — offset (1-based, default 1) + limit (default all).
+        const offset = Math.min(toPosInt(args.offset, 1), total);
+        const limit = Math.min(toPosInt(args.limit, total - offset + 1), 2000);
+        const slice = lines.slice(offset - 1, offset - 1 + limit);
+        const numbered = slice.map((l, i) => `${offset + i}: ${l}`).join("\n");
+        const end = offset + slice.length - 1;
+        const header = offset > 1 || end < total ? `[lines ${offset}-${end} of ${total} — ${args.path}]\n` : "";
+        return { ok: true, output: clamp(header + numbered) };
+    });
+}

package/dist/tools/registry.js

@@ -0,0 +1,297 @@
+import { findSkill, discoverSkills, loadSkillSection } from "../context/skills.js";
+import { buildRepoMap, renderRepoMap } from "../context/repo-map.js";
+import { toolWebFetch } from "./webfetch.js";
+import { toolReadFile } from "./read-file.js";
+import { toolWriteFile } from "./write-file.js";
+import { toolEditFile } from "./edit-file.js";
+import { toolApplyPatch } from "./apply-patch.js";
+import { toolListFiles } from "./list-files.js";
+import { toolGrep, toolGlob } from "./search.js";
+import { toolRunCommand } from "./run-command.js";
+import { taskTool } from "./task-tool.js";
+import { obj, str, num } from "./schemas.js";
+export const AGENT_TOOLS = [
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "load_skill",
+                description: "Load the full instructions of a named skill from the AVAILABLE SKILLS index (project + global). Call this at the start of a task when it matches a skill, then follow the returned instructions exactly.",
+                parameters: obj({
+                    name: str("Skill name ONLY, exactly as listed in the AVAILABLE SKILLS index, e.g. 'prompt-gate-workflow' — do NOT append task text."),
+                    section: str("Optional section heading to load (progressive disclosure). Omit for full body."),
+                }, ["name"]),
+            },
+        },
+        run: (ctx, args) => {
+            const name = String(args.name ?? "").trim();
+            if (!name)
+                return { ok: false, output: "ERROR: name is required — pick one from the AVAILABLE SKILLS index." };
+            const skill = findSkill(ctx.workdir, name);
+            if (!skill) {
+                const names = discoverSkills(ctx.workdir).map((s) => s.name).join(", ");
+                return { ok: false, output: `ERROR: skill "${name}" not found${names ? ` — available: ${names}` : " — no skills discovered"}.` };
+            }
+            const section = args.section;
+            const body = section ? loadSkillSection(skill, String(section)) : skill.body;
+            const refs = skill.references?.length ? `\n\nReferences: ${skill.references.join(", ")}` : "";
+            return { ok: true, output: `# skill: ${skill.name} (${skill.scope})${skill.version ? ` v${skill.version}` : ""}\n\n${body}${refs}` };
+        },
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "write_todos",
+                description: "Write the full task plan (replaces the previous list). Use at the start of a multi-step task and update as you go: mark items completed IMMEDIATELY after finishing them, set exactly one item in_progress, and add newly discovered steps. " +
+                    "v2: each item may carry verify (how you will know it's done), depends_on (earlier step ids), files (expected paths) and acceptance (criteria). The user sees this list live.",
+                parameters: obj({
+                    todos: {
+                        type: "array",
+                        description: "The complete todo list (full replacement).",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: { type: "string", description: "Stable step id (e.g. 't1'). Auto-assigned when omitted." },
+                                content: { type: "string", description: "Imperative step, e.g. 'Fix null check in UserService'" },
+                                status: { type: "string", enum: ["pending", "in_progress", "completed"] },
+                                verify: { type: "string", description: "How to verify the step — command or observable behavior" },
+                                depends_on: { type: "array", items: { type: "string" }, description: "Ids of steps that must complete first" },
+                                files: { type: "array", items: { type: "string" }, description: "Files this step is expected to touch" },
+                                acceptance: { type: "string", description: "Criteria for the step to count as done" },
+                            },
+                            required: ["content", "status"],
+                            additionalProperties: false,
+                        },
+                    },
+                }, ["todos"]),
+            },
+        },
+        run: (ctx, args) => {
+            const todos = args.todos;
+            if (!Array.isArray(todos))
+                return { ok: false, output: "ERROR: todos must be an array of {content, status}." };
+            const clean = [];
+            for (const [i, t] of todos.entries()) {
+                if (typeof t?.content !== "string" || !t.content.trim()) {
+                    return { ok: false, output: "ERROR: every todo needs a non-empty content string." };
+                }
+                if (!["pending", "in_progress", "completed"].includes(t.status)) {
+                    return { ok: false, output: `ERROR: invalid status "${String(t.status)}" (pending|in_progress|completed).` };
+                }
+                const item = {
+                    id: typeof t.id === "string" && t.id.trim() ? t.id.trim().slice(0, 32) : `t${i + 1}`,
+                    content: t.content.trim().slice(0, 200),
+                    status: t.status,
+                };
+                if (typeof t.verify === "string" && t.verify.trim())
+                    item.verify = t.verify.trim().slice(0, 300);
+                if (typeof t.acceptance === "string" && t.acceptance.trim())
+                    item.acceptance = t.acceptance.trim().slice(0, 300);
+                if (Array.isArray(t.depends_on))
+                    item.depends_on = t.depends_on.filter((x) => typeof x === "string").slice(0, 10);
+                if (Array.isArray(t.files))
+                    item.files = t.files.filter((x) => typeof x === "string").slice(0, 20);
+                clean.push(item);
+            }
+            // v2 rule: exactly one in_progress at a time.
+            const inProgress = clean.filter((t) => t.status === "in_progress");
+            if (inProgress.length > 1) {
+                return { ok: false, output: `ERROR: exactly one in_progress step allowed (got ${inProgress.length}: ${inProgress.map((t) => t.content).join(" | ")}). Mark the others pending or completed.` };
+            }
+            // v2 rule: depends_on must reference earlier ids in the SAME plan.
+            const ids = new Set(clean.map((t) => t.id));
+            for (const t of clean) {
+                for (const dep of t.depends_on ?? []) {
+                    if (!ids.has(dep))
+                        return { ok: false, output: `ERROR: step "${t.content}" depends_on unknown id "${dep}" — ids in this plan: ${[...ids].join(", ")}` };
+                }
+            }
+            ctx.plan?.set(clean);
+            const done = clean.filter((t) => t.status === "completed").length;
+            const next = clean.find((t) => t.status === "in_progress");
+            return { ok: true, output: `Plan updated: ${done}/${clean.length} completed.${next ? ` In progress: ${next.content}` : " (none in progress)"}` };
+        },
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "list_files",
+                description: "List files and directories recursively under a path in the working directory. Hidden dotfiles are excluded unless include_hidden=true; pass depth / exclude to shape the output.",
+                parameters: obj({
+                    path: str("Relative path, defaults to '.'"),
+                    depth: num("Max directory depth to recurse (default 4, cap 8)"),
+                    exclude: str("Comma/space-separated globs to exclude, e.g. '*.log,coverage'"),
+                    include_hidden: str("'true' to include dotfiles (default: excluded)"),
+                }, []),
+            },
+        },
+        run: (ctx, args) => toolListFiles(ctx.workdir, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "read_file",
+                description: "Read a text file. Returns content with 1-based line numbers. Pass offset (1-based start line) and limit to read a slice instead of the whole file. Image files (PNG/JPG/GIF) return an `[image: path]` placeholder rendered inline by the TUI.",
+                parameters: obj({
+                    path: str("Relative file path"),
+                    offset: num("1-based line to start from (default: 1)"),
+                    limit: num("Max lines to read (default: whole file, capped at 2000)"),
+                }, ["path"]),
+            },
+        },
+        run: (ctx, args) => toolReadFile(ctx.workdir, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "write_file",
+                description: "Create or overwrite a file with the given full content. Parent dirs are created automatically.",
+                parameters: obj({ path: str("Relative file path"), content: str("Full file content") }, ["path", "content"]),
+            },
+        },
+        run: (ctx, args) => toolWriteFile(ctx, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "edit_file",
+                description: "Replace an exact unique substring in a file. old_string must appear exactly once; include enough surrounding context. " +
+                    "For multiple replacements in the same file, use apply_patch (atomic, one write).",
+                parameters: obj({
+                    path: str("Relative file path"),
+                    old_string: str("Exact text to replace"),
+                    new_string: str("Replacement text"),
+                }, ["path", "old_string", "new_string"]),
+            },
+        },
+        run: (ctx, args) => toolEditFile(ctx, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "apply_patch",
+                description: "Apply multiple exact replacements to ONE file atomically. Edits run in order; each old_string must match exactly once " +
+                    "in the content produced by the previous edits. If any edit fails, nothing is written. " +
+                    "Use this instead of repeated edit_file calls for multi-hunk changes.",
+                parameters: obj({
+                    path: str("Relative file path"),
+                    edits: {
+                        type: "array",
+                        description: "Ordered list of replacements applied atomically (1–50).",
+                        items: obj({
+                            old_string: str("Exact text to replace (must be unique at its turn)"),
+                            new_string: str("Replacement text"),
+                        }, ["old_string", "new_string"]),
+                    },
+                }, ["path", "edits"]),
+            },
+        },
+        run: (ctx, args) => toolApplyPatch(ctx, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "run_command",
+                description: "Run a shell command in the working directory (sh/bash -c; Windows: Git Bash when installed, else cmd /c). Use for builds, tests, git, installing deps, etc.",
+                parameters: obj({
+                    command: str("Shell command to run"),
+                    timeout_secs: num("Timeout in seconds (default 120, max 600)"),
+                }, ["command"]),
+            },
+        },
+        run: (ctx, args) => toolRunCommand(ctx.workdir, args, ctx.signal, ctx.onToolOutput ? (stream, delta) => ctx.onToolOutput?.("run_command", stream, delta) : undefined, ctx.sandbox, ctx.reporter),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "web_fetch",
+                description: "Fetch a public HTTP(S) URL and return its content as readable plain text " +
+                    "(HTML converted to text, JSON pretty-printed). WHEN TO USE: the task depends on external, " +
+                    "possibly outdated knowledge — library/API documentation, an error message or comment " +
+                    "containing a URL, current package versions or changelogs, standards/specs. " +
+                    "WHEN NOT TO: the answer is already in the working directory or in the user's request; " +
+                    "you need a search engine (this tool fetches exact URLs only, it cannot search); " +
+                    "the content is a binary file (images, archives, PDFs are refused). " +
+                    "Private/internal addresses (localhost, 10.x, 192.168.x, 127.x) are blocked.",
+                parameters: obj({
+                    url: str("Absolute http(s) URL to fetch"),
+                    max_chars: str("Max characters of extracted content to return (default 20000, max 100000)"),
+                }, ["url"]),
+            },
+        },
+        run: (ctx, args) => toolWebFetch(ctx, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "grep",
+                description: "Search file contents with a regex (ripgrep-backed, gitignore-aware). Returns path:line:text hits (max 50 by default), with optional context lines and a hit cap. " +
+                    "Use for finding code by symbol, error string, or pattern. Combine with read_file for full context.",
+                parameters: obj({
+                    pattern: str("Regular expression to search for"),
+                    path: str("Directory or file to search (default: workdir root)"),
+                    include: str("Glob filter for filenames, e.g. '*.ts'"),
+                    context_before: num("Context lines to print before each match (default 0)"),
+                    context_after: num("Context lines to print after each match (default 0)"),
+                    max_results: num("Max matching lines to return (default 50, cap 100)"),
+                    type: str("ripgrep file type filter, e.g. 'ts', 'py' (rg only; ignored by fallbacks)"),
+                }, ["pattern"]),
+            },
+        },
+        run: (ctx, args) => toolGrep(ctx.workdir, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "glob",
+                description: "Find files by glob pattern (supports **, *, ?, {a,b}). Returns matching paths sorted, max 200. " +
+                    "Use when you know the filename shape but not the location.",
+                parameters: obj({
+                    pattern: str("Glob pattern relative to workdir, e.g. 'src/**/*.ts'"),
+                    path: str("Directory to search (default: workdir root)"),
+                }, ["pattern"]),
+            },
+        },
+        run: (ctx, args) => toolGlob(ctx.workdir, args),
+    },
+    {
+        spec: {
+            type: "function",
+            function: {
+                name: "repo_map",
+                description: "Return the repository map — file tree with sizes + exported symbols (regex-extracted, budget-bounded, cached). " +
+                    "Use to orient before reading files; cheaper than listing/reading everything.",
+                parameters: obj({ path: str("Sub-directory to map (default: repo root)") }, []),
+            },
+        },
+        run: (ctx, args) => {
+            try {
+                const sub = typeof args.path === "string" ? args.path.trim() : "";
+                const out = sub
+                    ? renderRepoMap(ctx.workdir, 4000, sub)
+                    : buildRepoMap(ctx.workdir);
+                return { ok: true, output: out };
+            }
+            catch (err) {
+                return { ok: false, output: `ERROR: repo map failed: ${err.message}` };
+            }
+        },
+    },
+];
+export function getTool(name) {
+    return AGENT_TOOLS.find((t) => t.spec.function.name === name) ?? (name === "task" ? taskTool : undefined);
+}
+/** All tool specs incl. task (agent adds MCP specs on top). */
+export function allToolSpecs() {
+    return [...AGENT_TOOLS.map((t) => t.spec), taskTool.spec];
+}

package/dist/tools/run-command.js

@@ -0,0 +1,192 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { loadRcFile } from "../config/config.js";
+import { resolveSandbox } from "../security/sandbox.js";
+import { consoleReporter } from "../io/console-reporter.js";
+import { clamp, MAX_OUTPUT_CHARS } from "./path-safety.js";
+import { redactSecrets } from "../llm/llm.js";
+// ── G3: child env allowlist ─────────────────────────────────────────────────
+// spawn /bin/sh -c with the FULL process.env leaks every secret in the shell's
+// environment (API keys, tokens) to any command the model runs — and thus to
+// the conversation/log via `env` or a misbehaving tool. Allowlist instead.
+/** Always passed through — minimum for node/python/git builds to work. */
+const BASE_ENV_KEYS = [
+    "PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "TERM", "SHELL", "USER", "LOGNAME", "XDG_CONFIG_HOME", "XDG_CACHE_HOME", "XDG_DATA_HOME",
+    // Windows essentiels — cmd.exe/npm.cmd cần SystemRoot/ComSpec/PATHEXT để chạy;
+    // Node trên Windows tra env key không phân biệt hoa thường nên viết hoa cũng khớp.
+    "SYSTEMROOT", "SYSTEMDRIVE", "COMSPEC", "PATHEXT", "WINDIR", "TEMP", "TMP",
+    "USERPROFILE", "HOMEDRIVE", "HOMEPATH", "APPDATA", "LOCALAPPDATA", "PROGRAMDATA",
+    "PROGRAMFILES", "PROGRAMFILES(X86)", "PUBLIC", "NUMBER_OF_PROCESSORS", "PROCESSOR_ARCHITECTURE",
+];
+/**
+ * G3: build the child env. Base keys + SCODER_* config + explicit extras from
+ * the rc (`shellEnvAllow`), resolved from process.env. Missing keys are absent
+ * (not empty) so tools detect them correctly.
+ */
+export function buildChildEnv(workdir, extraKeys) {
+    const rc = loadRcFile(workdir);
+    const allow = [...BASE_ENV_KEYS, ...(rc.shellEnvAllow ?? []), ...(extraKeys ?? [])];
+    const out = {};
+    for (const k of allow) {
+        const v = process.env[k];
+        if (v !== undefined)
+            out[k] = v;
+    }
+    // Windows + Git Bash: không có HOME — git/bash đọc config từ ~ (.gitconfig,
+    // ssh keys). Map HOME → USERPROFILE để git hoạt động đúng user hiện tại.
+    if (process.platform === "win32" && out.HOME === undefined && out.USERPROFILE) {
+        out.HOME = out.USERPROFILE;
+    }
+    return out;
+}
+/**
+ * Shell mặc định theo platform:
+ * - Unix → /bin/sh -c.
+ * - Windows → Git Bash nếu tìm thấy (model hay emit cú pháp POSIX: pipes, grep,
+ *   rm -rf — cmd.exe không chạy được), fallback cmd.exe /d /c.
+ *   KHÔNG dùng `where bash` — System32\bash.exe là WSL (sai filesystem).
+ */
+export function defaultShellArgv(command) {
+    if (process.platform === "win32") {
+        const bash = findGitBash();
+        if (bash)
+            return [bash, "-c", command];
+        return [process.env.ComSpec || process.env.COMSPEC || "cmd.exe", "/d", "/c", command];
+    }
+    return ["/bin/sh", "-c", command];
+}
+/** Locate Git for Windows' bash.exe (cached); null when not installed. */
+let gitBashCache;
+function findGitBash() {
+    if (gitBashCache !== undefined)
+        return gitBashCache;
+    const pf = process.env.ProgramFiles ?? "C:\\Program Files";
+    const pf86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+    const local = process.env.LOCALAPPDATA;
+    const candidates = [
+        join(pf, "Git", "bin", "bash.exe"),
+        join(pf86, "Git", "bin", "bash.exe"),
+        ...(local ? [join(local, "Programs", "Git", "bin", "bash.exe")] : []),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c)) {
+            gitBashCache = c;
+            return c;
+        }
+    }
+    gitBashCache = null;
+    return null;
+}
+/**
+ * Run a shell command asynchronously (async spawn keeps the event loop free,
+ * so streaming output renders and SIGINT is handled promptly).
+ * Kills the child on timeout or external abort (SIGINT via ctx.signal).
+ * When `onOutput` is provided, stdout/stderr chunks are forwarded live as they
+ * arrive (in addition to being collected into the final ToolResult).
+ * G3: output is redacted (secret shapes) before it enters the conversation,
+ * the live stream, or the JSONL log.
+ */
+export async function toolRunCommand(workdir, args, signal, onOutput, sandbox, reporter = consoleReporter) {
+    const timeoutMs = Math.min(Math.max(args.timeout_secs ?? 120, 1), 600) * 1000;
+    // G3: the echoed command line itself may contain a secret (e.g. `curl -H
+    // "Authorization: Bearer sk-..."`) — redact the echo, never run redacted
+    // (the child gets the raw command).
+    const echoLine = `$ ${redactSecrets(args.command)}`;
+    // G4: sandbox wrap khi config bật. Wrapper thiếu → warn + chạy trực tiếp.
+    const sandboxed = await resolveSandbox(sandbox ?? {}, workdir, args.command);
+    if (sandboxed.argv) {
+        reporter.info(`sandbox: ${sandboxed.wrapper} (${(sandbox ?? {}).mode})`);
+    }
+    else if ((sandbox ?? {}).mode && (sandbox ?? {}).mode !== "off") {
+        reporter.warn(`sandbox: ${sandboxed.reason}`);
+    }
+    const spawnArgv = sandboxed.argv ?? defaultShellArgv(args.command);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            resolve(result);
+        };
+        const child = spawn(spawnArgv[0], spawnArgv.slice(1), {
+            cwd: workdir,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: buildChildEnv(workdir), // G3: allowlist — không kế thừa full process.env
+        });
+        let stdout = "";
+        let stderr = "";
+        let killedReason = null;
+        const killChild = (reason) => {
+            killedReason = reason;
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { /* already dead */ }
+            // SIGKILL fallback if the process ignores SIGTERM
+            setTimeout(() => {
+                try {
+                    if (child.exitCode === null)
+                        child.kill("SIGKILL");
+                }
+                catch { /* already dead */ }
+            }, 5_000).unref();
+        };
+        const timer = setTimeout(() => killChild("timeout"), timeoutMs);
+        const onAbort = () => killChild("aborted");
+        if (signal?.aborted)
+            onAbort();
+        else
+            signal?.addEventListener("abort", onAbort, { once: true });
+        child.stdout?.on("data", (c) => {
+            const s = c.toString("utf8");
+            if (stdout.length < MAX_OUTPUT_CHARS)
+                stdout += s.slice(0, MAX_OUTPUT_CHARS - stdout.length);
+            onOutput?.("stdout", redactSecrets(s)); // G3
+        });
+        child.stderr?.on("data", (c) => {
+            const s = c.toString("utf8");
+            if (stderr.length < MAX_OUTPUT_CHARS)
+                stderr += s.slice(0, MAX_OUTPUT_CHARS - stderr.length);
+            onOutput?.("stderr", redactSecrets(s)); // G3
+        });
+        child.on("error", (err) => {
+            finish({ ok: false, output: clamp(`${echoLine}\n(spawn error) ${err.message}`) });
+        });
+        child.on("close", (code) => {
+            if (killedReason === "timeout") {
+                finish({
+                    ok: false,
+                    output: clamp(`${echoLine}\n(command timed out after ${Math.round(timeoutMs / 1000)}s and was killed)\n--- stdout ---\n${redactSecrets(stdout)}\n--- stderr ---\n${redactSecrets(stderr)}`),
+                });
+                return;
+            }
+            if (killedReason === "aborted") {
+                finish({
+                    ok: false,
+                    output: clamp(`${echoLine}\n(interrupted by user)\n--- stdout ---\n${redactSecrets(stdout)}\n--- stderr ---\n${redactSecrets(stderr)}`),
+                });
+                return;
+            }
+            const status = code ?? -1;
+            // G3: redact trước khi output vào conversation/log/TUI.
+            const redacted = redactSecrets(stdout);
+            const redactedErr = redactSecrets(stderr);
+            if (status === 0) {
+                finish({ ok: true, output: clamp(`${echoLine}\n(exit 0)\n${redacted}`) });
+            }
+            else {
+                finish({
+                    ok: false,
+                    output: clamp(`${echoLine}\n(exit ${status})\n--- stdout ---\n${redacted}\n--- stderr ---\n${redactedErr}`),
+                });
+            }
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Tool registry
+// ---------------------------------------------------------------------------

package/dist/tools/schemas.js

@@ -0,0 +1,8 @@
+export const obj = (properties, required) => ({
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false,
+});
+export const str = (description) => ({ type: "string", description });
+export const num = (description) => ({ type: "number", description });