@cydm/magic-shell-agent-node 0.1.0

package/dist/claude-worker.js

@@ -0,0 +1,163 @@
+import { stripAnsi } from "./worker-output.js";
+function normalizeWhitespace(value) {
+    return stripAnsi(value || "")
+        .replace(/\r/g, "\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function normalizeComparable(value) {
+    return normalizeWhitespace(value)
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function isMostlyDecoration(line) {
+    return /^[\u2500-\u257f\u2580-\u259f\s]+$/u.test(line)
+        || /^[`~!@#$%^&*()_+=\-[\]{};:'",.<>/?\\|]+$/.test(line);
+}
+function isClaudeNoiseLine(line) {
+    const normalized = line.trim();
+    if (!normalized)
+        return true;
+    if (normalized.length < 2)
+        return true;
+    if (normalized === "rupt")
+        return true;
+    if (isMostlyDecoration(normalized))
+        return true;
+    if (/^\?+\s*for shortcuts$/i.test(normalized))
+        return true;
+    if (/^(esc|ctrl\+c|enter)\b/i.test(normalized))
+        return true;
+    if (/^claude code$/i.test(normalized))
+        return true;
+    if (/^claude$/i.test(normalized))
+        return true;
+    if (/^╭.*claude\s*code/i.test(normalized))
+        return true;
+    if (/^╰[─-]+╯$/u.test(normalized))
+        return true;
+    if (/^model:/i.test(normalized))
+        return true;
+    if (/^cwd:/i.test(normalized))
+        return true;
+    if (/^status:/i.test(normalized))
+        return true;
+    if (/^opus now defaults/i.test(normalized))
+        return true;
+    if (/^↑\s*opus now defaults/i.test(normalized))
+        return true;
+    if (/^[│┌┐└┘├┤┬┴┼].*/u.test(normalized))
+        return true;
+    if (/^[❯›»>]\s*/u.test(normalized))
+        return true;
+    if (/^[◐◑◒◓].*/u.test(normalized))
+        return true;
+    if (/^[✢✣✤✥✦✧✩✪✫✬✭✮✯✰✱✲✳✴✵✶✷✸✹✺✻✼✽].*/u.test(normalized))
+        return true;
+    if (/^⏵⏵\s*bypass permissions on/i.test(normalized))
+        return true;
+    if (/(shift\+tab to cycle|esc to interrupt)/i.test(normalized))
+        return true;
+    if (/\/effort\b/i.test(normalized))
+        return true;
+    if (/(percolating|thinking|pondering|brainstorming)/i.test(normalized))
+        return true;
+    if (/^▋|^▐|^▝|^▘|^█|^▛|^▜|^▌/u.test(normalized))
+        return true;
+    if (/^(thinking|working|ready|waiting)$/i.test(normalized))
+        return true;
+    if (/^(claude-|gpt-|qwen-|kimi-|local-|company-)/i.test(normalized))
+        return true;
+    return false;
+}
+function removeInputEcho(lines, input) {
+    const comparableInput = normalizeComparable(input);
+    if (!comparableInput)
+        return lines;
+    return lines.filter((line) => {
+        const comparable = normalizeComparable(line);
+        if (!comparable)
+            return false;
+        if (comparable === comparableInput)
+            return false;
+        if (comparableInput.includes(comparable) || comparable.includes(comparableInput))
+            return false;
+        return true;
+    });
+}
+export function isClaudeCodeWorker(agentType) {
+    return agentType === "claude-code";
+}
+export function claudeNeedsTrustConfirmation(bufferedOutput) {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return false;
+    return /quick safety check/i.test(cleaned)
+        || /accessing workspace:/i.test(cleaned)
+        || /yes,\s*i trust this folder/i.test(cleaned)
+        || /enter to confirm/i.test(cleaned);
+}
+export function formatClaudeTurnInput(message) {
+    if (!message)
+        return "\r";
+    if (message.endsWith("\r") || message.endsWith("\n"))
+        return message;
+    return `${message}\r`;
+}
+export function summarizeClaudeWorkerOutput(bufferedOutput, input = "") {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return "";
+    const lines = removeInputEcho(cleaned
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => !isClaudeNoiseLine(line)), input);
+    if (!lines.length)
+        return "";
+    return Array.from(new Set(lines)).slice(-4).join("\n").slice(-600);
+}
+export function getLastClaudeWorkerMessage(bufferedOutput, input = "") {
+    const summary = summarizeClaudeWorkerOutput(bufferedOutput, input);
+    if (!summary)
+        return "";
+    const lines = summary.split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines[lines.length - 1] || "";
+}
+export function getFreshClaudeTurnResult(beforeOutput, afterOutput, input) {
+    const delta = afterOutput.startsWith(beforeOutput) ? afterOutput.slice(beforeOutput.length) : afterOutput;
+    const deltaSummary = summarizeClaudeWorkerOutput(delta, input);
+    if (deltaSummary) {
+        const deltaLines = deltaSummary.split("\n").map((line) => line.trim()).filter(Boolean);
+        return {
+            message: deltaLines[deltaLines.length - 1] || "",
+            summary: deltaSummary,
+            changed: true,
+        };
+    }
+    const wholeSummary = summarizeClaudeWorkerOutput(afterOutput, input);
+    if (!wholeSummary) {
+        return { message: "", summary: "", changed: false };
+    }
+    const beforeSummary = summarizeClaudeWorkerOutput(beforeOutput, input);
+    if (wholeSummary === beforeSummary) {
+        return { message: "", summary: wholeSummary, changed: false };
+    }
+    const wholeLines = wholeSummary.split("\n").map((line) => line.trim()).filter(Boolean);
+    return {
+        message: wholeLines[wholeLines.length - 1] || "",
+        summary: wholeSummary,
+        changed: true,
+    };
+}
+export function isClaudeReadyForTask(bufferedOutput) {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return false;
+    if (claudeNeedsTrustConfirmation(cleaned))
+        return false;
+    return /for shortcuts/i.test(cleaned)
+        || /claude code/i.test(cleaned)
+        || cleaned.length > 80;
+}

package/dist/codex-exec.d.ts

@@ -0,0 +1,12 @@
+export interface CodexExecOptions {
+    cwd: string;
+    message: string;
+    timeoutMs: number;
+}
+export interface CodexExecResult {
+    message: string;
+    summary: string;
+    rawOutput: string;
+}
+export declare function extractCodexExecResult(rawOutput: string): CodexExecResult;
+export declare function runCodexExec(options: CodexExecOptions): Promise<CodexExecResult>;

package/dist/codex-exec.js

@@ -0,0 +1,84 @@
+import { spawn } from "node:child_process";
+function isRecord(value) {
+    return !!value && typeof value === "object";
+}
+export function extractCodexExecResult(rawOutput) {
+    const messages = [];
+    for (const line of rawOutput.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed.type === "item.completed"
+                && isRecord(parsed.item)
+                && parsed.item.type === "agent_message"
+                && typeof parsed.item.text === "string"
+                && parsed.item.text.trim()) {
+                messages.push(parsed.item.text.trim());
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    const uniqueMessages = Array.from(new Set(messages));
+    const summary = uniqueMessages.join("\n").trim();
+    return {
+        message: uniqueMessages[uniqueMessages.length - 1] || "",
+        summary,
+        rawOutput,
+    };
+}
+export async function runCodexExec(options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("codex", [
+            "exec",
+            "--json",
+            "--skip-git-repo-check",
+            "--dangerously-bypass-approvals-and-sandbox",
+            "-C",
+            options.cwd,
+            options.message,
+        ], {
+            cwd: options.cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (handler) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutHandle);
+            handler();
+        };
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (error) => {
+            finish(() => reject(error));
+        });
+        child.on("close", (code) => {
+            finish(() => {
+                const rawOutput = [stdout, stderr].filter(Boolean).join("");
+                if (code !== 0) {
+                    reject(new Error(rawOutput.trim() || `codex exec exited with code ${code}`));
+                    return;
+                }
+                resolve(extractCodexExecResult(rawOutput));
+            });
+        });
+        const timeoutHandle = setTimeout(() => {
+            child.kill("SIGTERM");
+            const error = new Error(`codex exec timed out after ${options.timeoutMs}ms`);
+            error.code = "CODEX_EXEC_TIMEOUT";
+            finish(() => reject(error));
+        }, Math.max(options.timeoutMs, 250));
+    });
+}

package/dist/codex-worker.d.ts

@@ -0,0 +1,12 @@
+export interface CodexTurnResult {
+    message: string;
+    summary: string;
+    changed: boolean;
+}
+export declare function isCodexWorker(agentType: string | undefined): boolean;
+export declare function codexNeedsTrustConfirmation(bufferedOutput: string): boolean;
+export declare function isCodexReadyForTask(bufferedOutput: string): boolean;
+export declare function formatCodexTurnInput(message: string): string;
+export declare function summarizeCodexWorkerOutput(bufferedOutput: string, input?: string): string;
+export declare function getLastCodexWorkerMessage(bufferedOutput: string, input?: string): string;
+export declare function getFreshCodexTurnResult(beforeOutput: string, afterOutput: string, input: string): CodexTurnResult;

package/dist/codex-worker.js

@@ -0,0 +1,179 @@
+import { stripAnsi } from "./worker-output.js";
+function normalizeWhitespace(value) {
+    return stripAnsi(value || "")
+        .replace(/\r/g, "\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function normalizeComparable(value) {
+    return normalizeWhitespace(value)
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function isCodexNoiseLine(line) {
+    const normalized = line.trim();
+    if (!normalized)
+        return true;
+    if (normalized.length < 2)
+        return true;
+    if (/^\d+\.?$/i.test(normalized))
+        return true;
+    if (/^v?\d+\.\d+\.\d+$/i.test(normalized))
+        return true;
+    if (/openai codex/i.test(normalized))
+        return true;
+    if (/^>_\s*openai codex/i.test(normalized))
+        return true;
+    if (/^model:\s*/i.test(normalized))
+        return true;
+    if (/^directory:\s*/i.test(normalized))
+        return true;
+    if (/^tip:\s*/i.test(normalized))
+        return true;
+    if (/^press enter to continue$/i.test(normalized))
+        return true;
+    if (/^do you trust the contents of this directory\?/i.test(normalized))
+        return true;
+    if (/^working with untrusted contents/i.test(normalized))
+        return true;
+    if (/prompt injection/i.test(normalized))
+        return true;
+    if (/^1\.\s*yes,\s*continue/i.test(normalized))
+        return true;
+    if (/^2\.\s*no,\s*quit/i.test(normalized))
+        return true;
+    if (/^find and fix a bug in @filename$/i.test(normalized))
+        return true;
+    if (/^gpt-[\w.-]+\s+.+% left/i.test(normalized))
+        return true;
+    if (/^\d+% left\b/i.test(normalized))
+        return true;
+    if (/^working \(\d+s/i.test(normalized))
+        return true;
+    if (/^(esc to interrupt|press enter to continue)$/i.test(normalized))
+        return true;
+    if (/^(you are in|continue anyway\? \[y\/n\]:)/i.test(normalized))
+        return true;
+    if (/^https?:\/\//i.test(normalized))
+        return true;
+    if (/^[╭╰│─]+$/u.test(normalized))
+        return true;
+    return false;
+}
+function removeInputEcho(lines, input) {
+    const comparableInput = normalizeComparable(input);
+    if (!comparableInput)
+        return lines;
+    return lines.filter((line) => {
+        const comparable = normalizeComparable(line);
+        if (!comparable)
+            return false;
+        if (comparable === comparableInput)
+            return false;
+        if (comparableInput.includes(comparable) || comparable.includes(comparableInput))
+            return false;
+        return true;
+    });
+}
+function cleanCodexLine(line) {
+    return line
+        .replace(/^[•●◦▪▸▹►▻]\s*/u, "")
+        .replace(/^[›>]\s*/u, "")
+        .trim();
+}
+function stripInlineCodexNoise(value) {
+    return value
+        .replace(/│\s*model:[^│]*│/gi, " ")
+        .replace(/│\s*directory:[^│]*│/gi, " ")
+        .replace(/[╭╰│─]+/gu, " ")
+        .replace(/working\s*\(\d+s\s*•\s*esc to interrupt\)/gi, " ")
+        .replace(/gpt-[\w.-]+\s+medium\s+·\s+\d+% left\s+·\s+[^\n]+/gi, " ")
+        .replace(/[›>]\s*implement \{feature\}/gi, " ")
+        .replace(/find and fix a bug in @filename/gi, " ")
+        .replace(/[•◦]\d+/g, " ")
+        .replace(/W[◦•]?(?:W|o|r|k|i|n|g|\d|•|◦)+/g, " ")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+}
+function extractSentenceCandidates(line) {
+    const normalized = stripInlineCodexNoise(line);
+    if (!normalized)
+        return [];
+    const matches = normalized.match(/[^.!?。！？\n]+[.!?。！？]/g);
+    if (matches?.length) {
+        return [matches.map((item) => item.trim()).filter(Boolean).join(" ").trim()].filter(Boolean);
+    }
+    return [normalized];
+}
+export function isCodexWorker(agentType) {
+    return agentType === "codex";
+}
+export function codexNeedsTrustConfirmation(bufferedOutput) {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return false;
+    return /do you trust the contents of this directory\?/i.test(cleaned)
+        || /press enter to continue/i.test(cleaned);
+}
+export function isCodexReadyForTask(bufferedOutput) {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return false;
+    return /openai codex/i.test(cleaned)
+        || /find and fix a bug in @filename/i.test(cleaned)
+        || /gpt-[\w.-]+.+% left/i.test(cleaned);
+}
+export function formatCodexTurnInput(message) {
+    if (!message)
+        return "\r";
+    if (message.endsWith("\r") || message.endsWith("\n"))
+        return message;
+    return `${message}\r`;
+}
+export function summarizeCodexWorkerOutput(bufferedOutput, input = "") {
+    const cleaned = normalizeWhitespace(bufferedOutput);
+    if (!cleaned)
+        return "";
+    const lines = removeInputEcho(cleaned
+        .split("\n")
+        .flatMap((line) => extractSentenceCandidates(cleanCodexLine(line)))
+        .filter((line) => !isCodexNoiseLine(line)), input);
+    if (!lines.length)
+        return "";
+    return Array.from(new Set(lines)).slice(-4).join("\n").slice(-600);
+}
+export function getLastCodexWorkerMessage(bufferedOutput, input = "") {
+    const summary = summarizeCodexWorkerOutput(bufferedOutput, input);
+    if (!summary)
+        return "";
+    const lines = summary.split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines[lines.length - 1] || "";
+}
+export function getFreshCodexTurnResult(beforeOutput, afterOutput, input) {
+    const delta = afterOutput.startsWith(beforeOutput) ? afterOutput.slice(beforeOutput.length) : afterOutput;
+    const deltaSummary = summarizeCodexWorkerOutput(delta, input);
+    if (deltaSummary) {
+        const deltaLines = deltaSummary.split("\n").map((line) => line.trim()).filter(Boolean);
+        return {
+            message: deltaLines[deltaLines.length - 1] || "",
+            summary: deltaSummary,
+            changed: true,
+        };
+    }
+    const wholeSummary = summarizeCodexWorkerOutput(afterOutput, input);
+    if (!wholeSummary) {
+        return { message: "", summary: "", changed: false };
+    }
+    const beforeSummary = summarizeCodexWorkerOutput(beforeOutput, input);
+    if (wholeSummary === beforeSummary) {
+        return { message: "", summary: wholeSummary, changed: false };
+    }
+    const wholeLines = wholeSummary.split("\n").map((line) => line.trim()).filter(Boolean);
+    return {
+        message: wholeLines[wholeLines.length - 1] || "",
+        summary: wholeSummary,
+        changed: true,
+    };
+}

package/dist/directory-browser.d.ts

@@ -0,0 +1,3 @@
+import type { ServerMessage } from "./types.js";
+export declare function buildDirectoryList(requestedPath?: string): Promise<ServerMessage>;
+export declare function findRepoRoot(startPath: string): Promise<string | null>;

package/dist/directory-browser.js

@@ -0,0 +1,48 @@
+import { access, readdir } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export async function buildDirectoryList(requestedPath) {
+    const normalizedPath = path.resolve(requestedPath || os.homedir());
+    try {
+        const entries = await readdir(normalizedPath, { withFileTypes: true });
+        const directories = entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => ({
+            name: entry.name,
+            path: path.join(normalizedPath, entry.name),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const parentPath = path.dirname(normalizedPath);
+        const repoRoot = await findRepoRoot(normalizedPath);
+        return {
+            type: "dir_list",
+            path: normalizedPath,
+            parentPath: parentPath === normalizedPath ? null : parentPath,
+            repoRoot,
+            entries: directories,
+        };
+    }
+    catch (err) {
+        return {
+            type: "error",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function findRepoRoot(startPath) {
+    let currentPath = startPath;
+    while (true) {
+        try {
+            await access(path.join(currentPath, ".git"));
+            return currentPath;
+        }
+        catch {
+            // keep walking up
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            return null;
+        }
+        currentPath = parentPath;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { AgentNode, type NodeOptions, main as runAgentNode } from "./node.js";
+export { getDefaultPluginDir } from "./plugin-loader.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { AgentNode, main as runAgentNode } from "./node.js";
+export { getDefaultPluginDir } from "./plugin-loader.js";

package/dist/local-direct-server.d.ts

@@ -0,0 +1,38 @@
+import type { ClientMessage, ServerMessage } from "@cydm/magic-shell-protocol";
+export interface LocalDirectServerOptions {
+    host: string;
+    port: number;
+    nodeId: string;
+    password: string;
+}
+export interface LocalDirectServerDelegate {
+    handleIncomingMessage(message: ClientMessage | ServerMessage): Promise<void>;
+    handleSubscriptionChange(sessionId: string, attachedBrowserCount: number): Promise<void> | void;
+}
+export declare class LocalDirectServer {
+    private readonly options;
+    private readonly delegate;
+    private httpServer;
+    private wsServer;
+    private connections;
+    private sessionToConnections;
+    private workbenchRoot;
+    constructor(options: LocalDirectServerOptions, delegate: LocalDirectServerDelegate);
+    start(): Promise<{
+        host: string;
+        port: number;
+        webUrl: string;
+        wsUrl: string;
+    }>;
+    stop(): Promise<void>;
+    handleNodeMessage(message: ServerMessage): void;
+    private handleHttpRequest;
+    private handleSocketConnection;
+    private handleBrowserMessage;
+    private attachConnectionToSession;
+    private detachConnectionFromSession;
+    private cleanupConnection;
+    private sendToSession;
+    private broadcast;
+    private send;
+}