@cydm/magic-shell-agent-node 0.1.0

package/dist/adapters/pty-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { AgentAdapter, AdapterInput, AdapterOutput, PluginConfig } from "./types.js";
+export declare class PtyAdapter implements AgentAdapter {
+    readonly name = "pty";
+    readonly description = "PTY native terminal adapter (supports vim, tmux)";
+    readonly capabilities: string[];
+    private agents;
+    private outputCallbacks;
+    private exitCallbacks;
+    canHandle(type: string): boolean;
+    start(config: PluginConfig): Promise<string>;
+    stop(agentId: string): Promise<void>;
+    sendInput(agentId: string, input: AdapterInput): void;
+    sendRawInput(agentId: string, data: string): void;
+    resize(agentId: string, cols: number, rows: number): void;
+    isRunning(agentId: string): boolean;
+    onOutput(callback: (agentId: string, output: AdapterOutput) => void): void;
+    onExit(callback: (agentId: string, code: number | null) => void): void;
+}

package/dist/adapters/pty-adapter.js

@@ -0,0 +1,99 @@
+import { spawn } from "node-pty";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class PtyAdapter {
+    name = "pty";
+    description = "PTY native terminal adapter (supports vim, tmux)";
+    capabilities = ["pty", "terminal", "ansi256", "interactive"];
+    agents = new Map();
+    outputCallbacks = [];
+    exitCallbacks = [];
+    canHandle(type) {
+        // PTY 可以处理任何类型
+        return true;
+    }
+    async start(config) {
+        const agentId = `pty-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const pty = spawn(config.command, config.args || [], {
+            name: "xterm-256color",
+            cols: 80,
+            rows: 24,
+            cwd: config.cwd || process.cwd(),
+            env: { ...process.env, ...config.env },
+        });
+        const agent = {
+            id: agentId,
+            pty,
+            config,
+        };
+        agent.outputCallback = (output) => {
+            for (const callback of this.outputCallbacks) {
+                callback(agentId, output);
+            }
+        };
+        agent.exitCallback = (code) => {
+            for (const callback of this.exitCallbacks) {
+                callback(agentId, code);
+            }
+        };
+        // 处理输出
+        pty.onData((data) => {
+            console.log(`[PtyAdapter ${agentId}] onData: ${data.length} chars, callback=${!!agent.outputCallback}`);
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "output",
+                content: data,
+            });
+        });
+        // 处理退出
+        pty.onExit(({ exitCode, signal }) => {
+            console.log(`[PtyAdapter] Agent ${agentId} exited: code=${exitCode}, signal=${signal}`);
+            agent.exitCallback?.(exitCode);
+            this.agents.delete(agentId);
+        });
+        this.agents.set(agentId, agent);
+        console.log(`[PtyAdapter] Started ${agentId}: ${config.command}`);
+        return agentId;
+    }
+    async stop(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        agent.pty.kill();
+        this.agents.delete(agentId);
+        console.log(`[PtyAdapter] Stopped ${agentId}`);
+    }
+    sendInput(agentId, input) {
+        // 普通输入
+        this.sendRawInput(agentId, input.text);
+    }
+    sendRawInput(agentId, data) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            console.warn(`[PtyAdapter] Agent ${agentId} not found`);
+            return;
+        }
+        agent.pty.write(data);
+    }
+    resize(agentId, cols, rows) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        agent.pty.resize(cols, rows);
+    }
+    isRunning(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return false;
+        // node-pty 没有直接的 running 状态，检查是否还在 agents Map 中
+        return true;
+    }
+    onOutput(callback) {
+        this.outputCallbacks.push(callback);
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+}

package/dist/adapters/registry.d.ts

@@ -0,0 +1,28 @@
+import type { AgentAdapter, PluginConfig } from "./types.js";
+/**
+ * 适配器注册表
+ * 管理所有可用的 Agent 适配器，根据配置自动选择
+ */
+export declare class AdapterRegistry {
+    private adapters;
+    private defaultAdapter?;
+    constructor();
+    /**
+     * 注册自定义适配器
+     */
+    register(adapter: AgentAdapter): void;
+    /**
+     * 根据插件配置查找适配器
+     * 优先匹配显式 type，其次匹配 canHandle，最后使用默认
+     */
+    findAdapter(config: PluginConfig): AgentAdapter;
+    /**
+     * 列出所有已注册的适配器
+     */
+    listAdapters(): Array<{
+        name: string;
+        description: string;
+        capabilities: string[];
+    }>;
+}
+export declare const adapterRegistry: AdapterRegistry;

package/dist/adapters/registry.js

@@ -0,0 +1,64 @@
+import { PtyAdapter } from "./pty-adapter.js";
+import { StdioAdapter } from "./stdio-adapter.js";
+import { RpcAdapter } from "./rpc-adapter.js";
+/**
+ * 适配器注册表
+ * 管理所有可用的 Agent 适配器，根据配置自动选择
+ */
+export class AdapterRegistry {
+    adapters = [];
+    defaultAdapter;
+    constructor() {
+        // 注册内置适配器
+        this.register(new PtyAdapter());
+        this.register(new StdioAdapter());
+        this.register(new RpcAdapter());
+        // PTY 作为默认适配器（通用性最强）
+        this.defaultAdapter = this.adapters[0];
+    }
+    /**
+     * 注册自定义适配器
+     */
+    register(adapter) {
+        this.adapters.push(adapter);
+        console.log(`[AdapterRegistry] Registered: ${adapter.name} - ${adapter.description}`);
+    }
+    /**
+     * 根据插件配置查找适配器
+     * 优先匹配显式 type，其次匹配 canHandle，最后使用默认
+     */
+    findAdapter(config) {
+        // 1. 根据 type 精确匹配，确保插件声明的适配器类型真正生效
+        for (const adapter of this.adapters) {
+            if (adapter.name === config.type) {
+                console.log(`[AdapterRegistry] Found by type: ${adapter.name}`);
+                return adapter;
+            }
+        }
+        // 2. 回退到能力匹配，允许通用适配器兜底
+        for (const adapter of this.adapters) {
+            if (adapter.canHandle(config.type)) {
+                console.log(`[AdapterRegistry] Found by canHandle: ${adapter.name} for type=${config.type}`);
+                return adapter;
+            }
+        }
+        // 3. 返回默认适配器
+        if (this.defaultAdapter) {
+            console.log(`[AdapterRegistry] Using default: ${this.defaultAdapter.name}`);
+            return this.defaultAdapter;
+        }
+        throw new Error(`No adapter available for type: ${config.type}`);
+    }
+    /**
+     * 列出所有已注册的适配器
+     */
+    listAdapters() {
+        return this.adapters.map((a) => ({
+            name: a.name,
+            description: a.description,
+            capabilities: a.capabilities,
+        }));
+    }
+}
+// 全局单例
+export const adapterRegistry = new AdapterRegistry();

package/dist/adapters/rpc-adapter.d.ts

@@ -0,0 +1,19 @@
+import type { AgentAdapter, AdapterInput, AdapterOutput, PluginConfig } from "./types.js";
+export declare class RpcAdapter implements AgentAdapter {
+    readonly name = "rpc";
+    readonly description = "JSON-RPC adapter for line-oriented RPC workers";
+    readonly capabilities: string[];
+    private agents;
+    private outputCallbacks;
+    private exitCallbacks;
+    canHandle(type: string): boolean;
+    start(config: PluginConfig): Promise<string>;
+    private handleLine;
+    private handleRpcEvent;
+    stop(agentId: string): Promise<void>;
+    sendInput(agentId: string, input: AdapterInput): void;
+    sendRawInput(agentId: string, data: string): void;
+    isRunning(agentId: string): boolean;
+    onOutput(callback: (agentId: string, output: AdapterOutput) => void): void;
+    onExit(callback: (agentId: string, code: number | null) => void): void;
+}

package/dist/adapters/rpc-adapter.js

@@ -0,0 +1,182 @@
+import { spawn } from "child_process";
+export class RpcAdapter {
+    name = "rpc";
+    description = "JSON-RPC adapter for line-oriented RPC workers";
+    capabilities = ["json-rpc", "tool-call", "streaming"];
+    agents = new Map();
+    outputCallbacks = [];
+    exitCallbacks = [];
+    canHandle(type) {
+        return type === "rpc";
+    }
+    async start(config) {
+        const agentId = `rpc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const proc = spawn(config.command, config.args || [], {
+            cwd: config.cwd || process.cwd(),
+            env: { ...process.env, ...config.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const agent = {
+            id: agentId,
+            process: proc,
+            config,
+            buffer: "",
+        };
+        agent.outputCallback = (output) => {
+            for (const callback of this.outputCallbacks) {
+                callback(agentId, output);
+            }
+        };
+        agent.exitCallback = (code) => {
+            for (const callback of this.exitCallbacks) {
+                callback(agentId, code);
+            }
+        };
+        // 处理 stdout（JSON 行协议）
+        proc.stdout?.on("data", (data) => {
+            const text = data.toString("utf-8");
+            agent.buffer += text;
+            // 按行分割处理
+            const lines = agent.buffer.split("\n");
+            agent.buffer = lines.pop() || ""; // 保留未完成的行
+            for (const line of lines) {
+                if (line.trim()) {
+                    this.handleLine(agent, line);
+                }
+            }
+        });
+        // 处理 stderr
+        proc.stderr?.on("data", (data) => {
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "error",
+                content: data.toString("utf-8"),
+            });
+        });
+        // 处理退出
+        proc.on("close", (code) => {
+            console.log(`[RpcAdapter] Agent ${agentId} exited: code=${code}`);
+            agent.exitCallback?.(code);
+            this.agents.delete(agentId);
+        });
+        this.agents.set(agentId, agent);
+        console.log(`[RpcAdapter] Started ${agentId}: ${config.command}`);
+        return agentId;
+    }
+    handleLine(agent, line) {
+        try {
+            const event = JSON.parse(line);
+            this.handleRpcEvent(agent, event);
+        }
+        catch {
+            // 非 JSON 行，当作普通输出
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "output",
+                content: line,
+            });
+        }
+    }
+    handleRpcEvent(agent, event) {
+        switch (event.type) {
+            case "thinking_delta": {
+                const content = event.delta || event.partial?.thinking || "";
+                if (content) {
+                    agent.outputCallback?.({
+                        timestamp: Date.now(),
+                        type: "output",
+                        content,
+                    });
+                }
+                break;
+            }
+            case "toolcall_start": {
+                const toolCall = event.toolCall || event.partial?.toolCall;
+                if (toolCall?.name) {
+                    agent.outputCallback?.({
+                        timestamp: Date.now(),
+                        type: "system",
+                        content: `🔧 Tool: ${toolCall.name} ${JSON.stringify(toolCall.arguments || {})}`,
+                    });
+                }
+                break;
+            }
+            case "text_delta":
+            case "content_block_delta": {
+                const text = event.delta?.text || event.delta || "";
+                if (text) {
+                    agent.outputCallback?.({
+                        timestamp: Date.now(),
+                        type: "output",
+                        content: text,
+                    });
+                }
+                break;
+            }
+            case "message":
+            case "message_end": {
+                if (event.message?.content) {
+                    agent.outputCallback?.({
+                        timestamp: Date.now(),
+                        type: "output",
+                        content: event.message.content,
+                    });
+                }
+                break;
+            }
+            case "error": {
+                agent.outputCallback?.({
+                    timestamp: Date.now(),
+                    type: "error",
+                    content: event.message || "Unknown error",
+                });
+                break;
+            }
+            default:
+                // 忽略其他事件类型
+                break;
+        }
+    }
+    async stop(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        agent.process.kill();
+        this.agents.delete(agentId);
+        console.log(`[RpcAdapter] Stopped ${agentId}`);
+    }
+    sendInput(agentId, input) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            console.warn(`[RpcAdapter] Agent ${agentId} not found`);
+            return;
+        }
+        if (!agent.process.stdin || agent.process.stdin.destroyed) {
+            console.warn(`[RpcAdapter] Agent ${agentId} stdin closed`);
+            return;
+        }
+        // RPC workers use a simple line-delimited JSON command envelope.
+        const command = {
+            id: `cmd-${Date.now()}`,
+            type: input.mode || "prompt",
+            message: input.text,
+        };
+        agent.process.stdin.write(`${JSON.stringify(command)}\n`);
+    }
+    sendRawInput(agentId, data) {
+        // RPC 模式不支持原始输入，转为普通输入
+        this.sendInput(agentId, { text: data });
+    }
+    isRunning(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return false;
+        return !agent.process.killed && agent.process.exitCode === null;
+    }
+    onOutput(callback) {
+        this.outputCallbacks.push(callback);
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+}

package/dist/adapters/stdio-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { AgentAdapter, AdapterInput, AdapterOutput, PluginConfig } from "./types.js";
+export declare class StdioAdapter implements AgentAdapter {
+    readonly name = "stdio";
+    readonly description = "Stdio pipe adapter for CLI agents";
+    readonly capabilities: string[];
+    private agents;
+    private outputCallbacks;
+    private exitCallbacks;
+    canHandle(type: string): boolean;
+    start(config: PluginConfig): Promise<string>;
+    stop(agentId: string): Promise<void>;
+    sendInput(agentId: string, input: AdapterInput): void;
+    sendRawInput(agentId: string, data: string): void;
+    isRunning(agentId: string): boolean;
+    onOutput(callback: (agentId: string, output: AdapterOutput) => void): void;
+    onExit(callback: (agentId: string, code: number | null) => void): void;
+}

package/dist/adapters/stdio-adapter.js

@@ -0,0 +1,107 @@
+import { spawn } from "child_process";
+export class StdioAdapter {
+    name = "stdio";
+    description = "Stdio pipe adapter for CLI agents";
+    capabilities = ["terminal", "stream", "interactive"];
+    agents = new Map();
+    outputCallbacks = [];
+    exitCallbacks = [];
+    canHandle(type) {
+        // stdio 模式处理 pie-unity、claude-code 等
+        return ["pie-unity", "claude-code", "aider", "stdio"].includes(type);
+    }
+    async start(config) {
+        const agentId = `stdio-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const proc = spawn(config.command, config.args || [], {
+            cwd: config.cwd || process.cwd(),
+            env: { ...process.env, ...config.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const agent = {
+            id: agentId,
+            process: proc,
+            config,
+        };
+        agent.outputCallback = (output) => {
+            for (const callback of this.outputCallbacks) {
+                callback(agentId, output);
+            }
+        };
+        agent.exitCallback = (code) => {
+            for (const callback of this.exitCallbacks) {
+                callback(agentId, code);
+            }
+        };
+        // 处理 stdout
+        proc.stdout?.on("data", (data) => {
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "output",
+                content: data.toString("utf-8"),
+            });
+        });
+        // 处理 stderr
+        proc.stderr?.on("data", (data) => {
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "error",
+                content: data.toString("utf-8"),
+            });
+        });
+        // 处理退出
+        proc.on("close", (code) => {
+            console.log(`[StdioAdapter] Agent ${agentId} exited: code=${code}`);
+            agent.exitCallback?.(code);
+            this.agents.delete(agentId);
+        });
+        proc.on("error", (err) => {
+            console.error(`[StdioAdapter] Agent ${agentId} error:`, err.message);
+            agent.outputCallback?.({
+                timestamp: Date.now(),
+                type: "error",
+                content: `Process error: ${err.message}`,
+            });
+            agent.exitCallback?.(1);
+            this.agents.delete(agentId);
+        });
+        this.agents.set(agentId, agent);
+        console.log(`[StdioAdapter] Started ${agentId}: ${config.command}`);
+        return agentId;
+    }
+    async stop(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return;
+        agent.process.kill();
+        this.agents.delete(agentId);
+        console.log(`[StdioAdapter] Stopped ${agentId}`);
+    }
+    sendInput(agentId, input) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            console.warn(`[StdioAdapter] Agent ${agentId} not found`);
+            return;
+        }
+        if (!agent.process.stdin || agent.process.stdin.destroyed) {
+            console.warn(`[StdioAdapter] Agent ${agentId} stdin closed`);
+            return;
+        }
+        agent.process.stdin.write(input.text);
+    }
+    sendRawInput(agentId, data) {
+        // stdio 模式与普通输入相同
+        this.sendInput(agentId, { text: data });
+    }
+    isRunning(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return false;
+        return !agent.process.killed && agent.process.exitCode === null;
+    }
+    onOutput(callback) {
+        this.outputCallbacks.push(callback);
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,17 @@
+import type { AgentAdapter, AdapterInput, AdapterOutput, PluginConfig } from "../types.js";
+export type { AgentAdapter, AdapterInput, AdapterOutput, PluginConfig };
+/** 运行中的 Agent 进程信息 */
+export interface ManagedAgent {
+    id: string;
+    config: PluginConfig;
+    process?: any;
+    startedAt: number;
+    lastActivity: number;
+    outputCallback?: (output: AdapterOutput) => void;
+    exitCallback?: (code: number | null) => void;
+}
+/** 适配器构造函数的参数 */
+export interface AdapterOptions {
+    pluginDir?: string;
+    logLevel?: "debug" | "info" | "warn" | "error";
+}

package/dist/adapters/types.js

@@ -0,0 +1,2 @@
+// Adapter 类型定义
+export {};

package/dist/claude-exec.d.ts

@@ -0,0 +1,11 @@
+export interface ClaudeExecOptions {
+    cwd: string;
+    message: string;
+    timeoutMs: number;
+}
+export interface ClaudeExecResult {
+    message: string;
+    summary: string;
+    rawOutput: string;
+}
+export declare function runClaudeExec(options: ClaudeExecOptions): Promise<ClaudeExecResult>;

package/dist/claude-exec.js

@@ -0,0 +1,54 @@
+import { spawn } from "node:child_process";
+export async function runClaudeExec(options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("claude", [
+            "-p",
+            "--dangerously-skip-permissions",
+            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 message = stdout.trim();
+                const rawOutput = [stdout, stderr].filter(Boolean).join("");
+                if (code !== 0) {
+                    reject(new Error(rawOutput.trim() || `claude -p exited with code ${code}`));
+                    return;
+                }
+                resolve({
+                    message,
+                    summary: message,
+                    rawOutput,
+                });
+            });
+        });
+        const timeoutHandle = setTimeout(() => {
+            child.kill("SIGTERM");
+            const error = new Error(`claude -p timed out after ${options.timeoutMs}ms`);
+            error.code = "CLAUDE_EXEC_TIMEOUT";
+            finish(() => reject(error));
+        }, Math.max(options.timeoutMs, 250));
+    });
+}

package/dist/claude-worker.d.ts

@@ -0,0 +1,12 @@
+export interface ClaudeTurnResult {
+    message: string;
+    summary: string;
+    changed: boolean;
+}
+export declare function isClaudeCodeWorker(agentType: string | undefined): boolean;
+export declare function claudeNeedsTrustConfirmation(bufferedOutput: string): boolean;
+export declare function formatClaudeTurnInput(message: string): string;
+export declare function summarizeClaudeWorkerOutput(bufferedOutput: string, input?: string): string;
+export declare function getLastClaudeWorkerMessage(bufferedOutput: string, input?: string): string;
+export declare function getFreshClaudeTurnResult(beforeOutput: string, afterOutput: string, input: string): ClaudeTurnResult;
+export declare function isClaudeReadyForTask(bufferedOutput: string): boolean;