whale-code 6.4.0

package/dist/cli/services/tools/shell-exec.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shell Execution — run_command and background process tools
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { ToolResult } from "../../../shared/types.js";
+export declare function runCommand(input: Record<string, unknown>): Promise<ToolResult>;
+export declare function bashOutput(input: Record<string, unknown>): ToolResult;
+export declare function killShell(input: Record<string, unknown>): ToolResult;
+export declare function listShellsFn(): ToolResult;

package/dist/cli/services/tools/shell-exec.js

@@ -0,0 +1,168 @@
+/**
+ * Shell Execution — run_command and background process tools
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { join } from "path";
+import { spawn } from "child_process";
+import { homedir } from "os";
+import { spawnBackground, readProcessOutput, killProcess, listProcesses } from "../background-processes.js";
+import { getGlobalEmitter } from "../agent-events.js";
+import { sandboxCommand, cleanupSandbox } from "../sandbox.js";
+import { debugLog } from "../debug-log.js";
+function resolvePath(p) {
+    if (p.startsWith("~/"))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+export async function runCommand(input) {
+    let command = input.command;
+    const cwd = input.working_directory ? resolvePath(input.working_directory) : undefined;
+    const timeout = Math.min(input.timeout || 30000, 300000);
+    const background = input.run_in_background;
+    const description = input.description;
+    debugLog("tools", `run_command: ${description || command.slice(0, 80)}`, { cwd, timeout, background });
+    // UX guardrail only — the sandbox (macOS) is the real security boundary.
+    // This catches obvious destructive commands before they reach the sandbox.
+    if (command.length > 10000) {
+        return { success: false, output: "Command too long (max 10000 chars)" };
+    }
+    const DANGEROUS_PATTERNS = [
+        /\brm\s+(-[a-z]*f[a-z]*\s+)?(-[a-z]*r[a-z]*\s+)?(\/|~)/i,
+        /\brm\s+(-[a-z]*r[a-z]*\s+)?(-[a-z]*f[a-z]*\s+)?(\/|~)/i,
+        /\bmkfs\b/i,
+        /\bdd\s+.*\bif=/i,
+        />\s*\/dev\/sd/,
+        /:\(\)\s*\{.*\|.*&\s*\}\s*;/,
+        /\bchmod\s+(-[a-z]*R[a-z]*\s+)?777\s+\//i,
+        /\bchown\s+(-[a-z]*R[a-z]*\s+).*\//i,
+        /\bcurl\b.*\|\s*(ba)?sh\b/i,
+        /\bwget\b.*\|\s*(ba)?sh\b/i,
+        /\b(python|perl|ruby|node)\s+-e\s+.*\b(system|exec|spawn)\b/i,
+        /base64\s+(-d|--decode)\s*\|\s*(ba)?sh/i,
+    ];
+    const command_lower = command.toLowerCase().replace(/\s+/g, " ");
+    if (DANGEROUS_PATTERNS.some((p) => p.test(command_lower))) {
+        return { success: false, output: "Command blocked for safety" };
+    }
+    // Apply sandbox wrapping (macOS only)
+    let sandboxProfilePath = null;
+    {
+        const effectiveCwd = cwd || process.cwd();
+        const sandboxResult = sandboxCommand(command, effectiveCwd);
+        command = sandboxResult.wrapped;
+        sandboxProfilePath = sandboxResult.profilePath;
+    }
+    // Background mode — spawn detached, validate, return with status
+    if (background) {
+        const result = await spawnBackground(command, { cwd, timeout: 600_000, description: input.description });
+        return { success: result.status === "running", output: result.message };
+    }
+    // Foreground async — spawn + stream output via events
+    return new Promise((resolve) => {
+        const stdout = [];
+        const stderr = [];
+        let killed = false;
+        const child = spawn(command, [], {
+            shell: true,
+            cwd,
+            env: { ...process.env, FORCE_COLOR: "0" },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const emitter = getGlobalEmitter();
+        child.stdout?.on("data", (data) => {
+            const text = data.toString();
+            stdout.push(text);
+            // Emit live output for UI streaming
+            for (const line of text.split("\n")) {
+                if (line.trim())
+                    emitter.emitToolOutput("run_command", line);
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            const text = data.toString();
+            stderr.push(text);
+            for (const line of text.split("\n")) {
+                if (line.trim())
+                    emitter.emitToolOutput("run_command", line);
+            }
+        });
+        // Timeout kill
+        const timer = setTimeout(() => {
+            if (!killed) {
+                killed = true;
+                child.kill("SIGTERM");
+                setTimeout(() => child.kill("SIGKILL"), 3000);
+            }
+        }, timeout);
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            cleanupSandbox(sandboxProfilePath);
+            const output = stdout.join("") + (stderr.length > 0 ? "\n" + stderr.join("") : "");
+            if (killed) {
+                resolve({ success: false, output: `Command timed out after ${timeout}ms.\n${output}`.slice(0, 5000) });
+            }
+            else if (code === 0) {
+                let out = output || "(no output)";
+                if (out.length > 500_000) {
+                    out = out.slice(0, 500_000) + `\n\n... (safety truncated — ${output.length.toLocaleString()} chars total)`;
+                }
+                resolve({ success: true, output: out });
+            }
+            else {
+                resolve({ success: false, output: `Exit code ${code ?? "?"}:\n${output}`.slice(0, 5000) });
+            }
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            cleanupSandbox(sandboxProfilePath);
+            resolve({ success: false, output: `Spawn error: ${err.message}` });
+        });
+    });
+}
+// Background tool handlers
+export function bashOutput(input) {
+    const id = input.bash_id;
+    const filter = input.filter;
+    const result = readProcessOutput(id, { filter });
+    if ("error" in result)
+        return { success: false, output: result.error };
+    const statusIcon = result.status === "running" ? "\u25CF" : result.status === "completed" ? "\u2713" : "\u2715";
+    const statusColor = result.status === "running" ? "running" : result.status === "completed" ? "completed" : "failed";
+    const lines = [];
+    lines.push(`${statusIcon} Process ${id} — ${statusColor}`);
+    if (result.exitCode !== undefined)
+        lines.push(`  Exit code: ${result.exitCode}`);
+    if (result.newOutput) {
+        lines.push(`  Output:`);
+        lines.push(result.newOutput);
+    }
+    if (result.newErrors) {
+        lines.push(`  Errors:`);
+        lines.push(result.newErrors);
+    }
+    if (!result.newOutput && !result.newErrors)
+        lines.push("  (no new output since last check)");
+    return { success: true, output: lines.join("\n") };
+}
+export function killShell(input) {
+    const id = (input.shell_id || input.bash_id);
+    const result = killProcess(id);
+    return { success: result.success, output: result.message };
+}
+export function listShellsFn() {
+    const procs = listProcesses();
+    if (procs.length === 0)
+        return { success: true, output: "No background processes." };
+    const lines = [`${procs.length} background process${procs.length !== 1 ? "es" : ""}:`, ""];
+    for (const p of procs) {
+        const icon = p.status === "running" ? "\u25CF" : p.status === "completed" ? "\u2713" : "\u2715";
+        lines.push(`  ${icon} ${p.id}  ${p.status}  ${p.runtime}`);
+        lines.push(`    ${p.command}`);
+        if (p.pid)
+            lines.push(`    PID: ${p.pid}`);
+        lines.push(`    stdout: ${p.outputLines} lines  stderr: ${p.errorLines} lines`);
+        lines.push("");
+    }
+    return { success: true, output: lines.join("\n") };
+}

package/dist/cli/services/tools/task-manager.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Task Manager — action-based CRUD task tracking with IDs and dependencies
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ * All consumers should import from local-tools.ts (re-export facade).
+ */
+interface TaskItem {
+    id: string;
+    subject: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed";
+    activeForm?: string;
+    owner?: string;
+    metadata?: Record<string, unknown>;
+    blocks: string[];
+    blockedBy: string[];
+    createdAt: string;
+}
+import { ToolResult } from "../../../shared/types.js";
+declare let taskState: TaskItem[];
+export declare function tasksTool(input: Record<string, unknown>): ToolResult;
+/** Load tasks from disk for a session */
+export declare function loadTodos(sessionId: string): void;
+/** Link tasks to a session for persistence */
+export declare function setTodoSessionId(id: string): void;
+/** Get current task state (for UI display) */
+export declare function getTodoState(): typeof taskState;
+export {};

package/dist/cli/services/tools/task-manager.js

@@ -0,0 +1,209 @@
+/**
+ * Task Manager — action-based CRUD task tracking with IDs and dependencies
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ * All consumers should import from local-tools.ts (re-export facade).
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+// ============================================================================
+// STATE
+// ============================================================================
+let taskState = [];
+let taskCounter = 0;
+let todoSessionId = null;
+const TODOS_DIR = join(homedir(), ".swagmanager", "todos");
+// ============================================================================
+// TOOL IMPLEMENTATION
+// ============================================================================
+export function tasksTool(input) {
+    const action = input.action;
+    if (!action)
+        return { success: false, output: "action is required (create/update/list/get)" };
+    switch (action) {
+        case "create": {
+            const subject = input.subject;
+            const description = input.description;
+            if (!subject || !description)
+                return { success: false, output: "subject and description required for create" };
+            taskCounter++;
+            const task = {
+                id: String(taskCounter),
+                subject,
+                description,
+                status: "pending",
+                activeForm: input.activeForm,
+                owner: input.owner,
+                metadata: input.metadata,
+                blocks: [],
+                blockedBy: [],
+                createdAt: new Date().toISOString(),
+            };
+            taskState.push(task);
+            persistTasks();
+            return { success: true, output: `Created task #${task.id}: ${subject}` };
+        }
+        case "update": {
+            const taskId = input.taskId;
+            if (!taskId)
+                return { success: false, output: "taskId required for update" };
+            const task = taskState.find((t) => t.id === taskId);
+            if (!task)
+                return { success: false, output: `Task #${taskId} not found` };
+            const newStatus = input.status;
+            // Handle deletion
+            if (newStatus === "deleted") {
+                // Remove from other tasks' blocks/blockedBy
+                for (const t of taskState) {
+                    t.blocks = t.blocks.filter((id) => id !== taskId);
+                    t.blockedBy = t.blockedBy.filter((id) => id !== taskId);
+                }
+                taskState = taskState.filter((t) => t.id !== taskId);
+                persistTasks();
+                return { success: true, output: `Deleted task #${taskId}` };
+            }
+            if (newStatus && ["pending", "in_progress", "completed"].includes(newStatus)) {
+                task.status = newStatus;
+            }
+            if (input.subject_update)
+                task.subject = input.subject_update;
+            if (input.description !== undefined)
+                task.description = input.description;
+            if (input.activeForm !== undefined)
+                task.activeForm = input.activeForm;
+            if (input.owner !== undefined)
+                task.owner = input.owner;
+            if (input.metadata) {
+                task.metadata = { ...(task.metadata || {}), ...input.metadata };
+                // Remove null keys
+                for (const [k, v] of Object.entries(task.metadata)) {
+                    if (v === null)
+                        delete task.metadata[k];
+                }
+            }
+            // Dependency management
+            const addBlocks = input.addBlocks;
+            const addBlockedBy = input.addBlockedBy;
+            if (addBlocks) {
+                for (const id of addBlocks) {
+                    if (!task.blocks.includes(id))
+                        task.blocks.push(id);
+                    const target = taskState.find((t) => t.id === id);
+                    if (target && !target.blockedBy.includes(taskId))
+                        target.blockedBy.push(taskId);
+                }
+            }
+            if (addBlockedBy) {
+                for (const id of addBlockedBy) {
+                    if (!task.blockedBy.includes(id))
+                        task.blockedBy.push(id);
+                    const target = taskState.find((t) => t.id === id);
+                    if (target && !target.blocks.includes(taskId))
+                        target.blocks.push(taskId);
+                }
+            }
+            persistTasks();
+            return { success: true, output: `Updated task #${taskId}: ${task.subject} [${task.status}]` };
+        }
+        case "list": {
+            if (taskState.length === 0)
+                return { success: true, output: "No tasks." };
+            const icon = { pending: "[ ]", in_progress: "[~]", completed: "[x]" };
+            const lines = taskState.map((t) => {
+                let line = `#${t.id}. ${icon[t.status] || "[ ]"} ${t.subject}`;
+                if (t.owner)
+                    line += ` (${t.owner})`;
+                // Show only open blockers
+                const openBlockers = t.blockedBy.filter((id) => {
+                    const blocker = taskState.find((b) => b.id === id);
+                    return blocker && blocker.status !== "completed";
+                });
+                if (openBlockers.length > 0)
+                    line += ` <- blocked by #${openBlockers.join(", #")}`;
+                return line;
+            });
+            const counts = {
+                pending: taskState.filter((t) => t.status === "pending").length,
+                in_progress: taskState.filter((t) => t.status === "in_progress").length,
+                completed: taskState.filter((t) => t.status === "completed").length,
+            };
+            return {
+                success: true,
+                output: `Tasks (${taskState.length}: ${counts.completed} done, ${counts.in_progress} active, ${counts.pending} pending):\n${lines.join("\n")}`,
+            };
+        }
+        case "get": {
+            const taskId = input.taskId;
+            if (!taskId)
+                return { success: false, output: "taskId required for get" };
+            const task = taskState.find((t) => t.id === taskId);
+            if (!task)
+                return { success: false, output: `Task #${taskId} not found` };
+            const details = [
+                `# Task #${task.id}: ${task.subject}`,
+                `Status: ${task.status}`,
+                task.owner ? `Owner: ${task.owner}` : null,
+                task.activeForm ? `Active form: ${task.activeForm}` : null,
+                `Created: ${task.createdAt}`,
+                task.blocks.length ? `Blocks: #${task.blocks.join(", #")}` : null,
+                task.blockedBy.length ? `Blocked by: #${task.blockedBy.join(", #")}` : null,
+                task.metadata ? `Metadata: ${JSON.stringify(task.metadata)}` : null,
+                "",
+                task.description,
+            ].filter(Boolean).join("\n");
+            return { success: true, output: details };
+        }
+        default:
+            return { success: false, output: `Unknown action: ${action}. Use create/update/list/get.` };
+    }
+}
+/** Persist tasks to disk (fire-and-forget) */
+function persistTasks() {
+    if (!todoSessionId)
+        return;
+    try {
+        if (!existsSync(TODOS_DIR))
+            mkdirSync(TODOS_DIR, { recursive: true });
+        writeFileSync(join(TODOS_DIR, `${todoSessionId}.json`), JSON.stringify({ tasks: taskState, counter: taskCounter }, null, 2), "utf-8");
+    }
+    catch { /* best effort */ }
+}
+/** Load tasks from disk for a session */
+export function loadTodos(sessionId) {
+    const path = join(TODOS_DIR, `${sessionId}.json`);
+    if (!existsSync(path))
+        return;
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        // Support both old format (array) and new format ({tasks, counter})
+        if (Array.isArray(raw)) {
+            // Migrate old todo format
+            taskState = raw.map((t, i) => ({
+                id: t.id || String(i + 1),
+                subject: t.content || t.subject || "Untitled",
+                description: t.content || t.description || "",
+                status: t.status || "pending",
+                activeForm: t.activeForm,
+                blocks: t.blocks || [],
+                blockedBy: t.blockedBy || [],
+                createdAt: t.createdAt || new Date().toISOString(),
+            }));
+            taskCounter = taskState.length;
+        }
+        else if (raw.tasks) {
+            taskState = raw.tasks;
+            taskCounter = raw.counter || taskState.length;
+        }
+        todoSessionId = sessionId;
+    }
+    catch { /* skip corrupted */ }
+}
+/** Link tasks to a session for persistence */
+export function setTodoSessionId(id) {
+    todoSessionId = id;
+}
+/** Get current task state (for UI display) */
+export function getTodoState() {
+    return taskState;
+}

package/dist/cli/services/tools/web-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Web Tools — web_fetch and web_search implementations
+ *
+ * Extracted from local-tools.ts for single-responsibility.
+ */
+import { ToolResult } from "../../../shared/types.js";
+export declare function isBlockedUrl(urlStr: string): boolean;
+export declare function webFetch(input: Record<string, unknown>): Promise<ToolResult>;
+/** Enhanced HTML -> readable text/markdown converter */
+export declare function htmlToText(html: string): string;
+export declare function webSearch(input: Record<string, unknown>): Promise<ToolResult>;