@heretyc/subagent-mcp 2.8.2 → 2.8.5

package/dist/drivers.js

@@ -0,0 +1,478 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+class LogicalProcess extends EventEmitter {
+    pid;
+    stdout = new PassThrough();
+    stderr = new PassThrough();
+    killed = false;
+    exitCode = null;
+    closed = false;
+    spawned = false;
+    constructor(pid, autoSpawn = false) {
+        super();
+        this.pid = pid;
+        this.on("error", () => { });
+        if (autoSpawn)
+            setImmediate(() => this.emit("spawn"));
+    }
+    emit(eventName, ...args) {
+        if (eventName === "spawn")
+            this.spawned = true;
+        return super.emit(eventName, ...args);
+    }
+    once(eventName, listener) {
+        if (eventName === "spawn" && this.spawned) {
+            queueMicrotask(() => listener.call(this));
+            return this;
+        }
+        return super.once(eventName, listener);
+    }
+    close(code, signal = null) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.exitCode = code;
+        this.emit("exit", code, signal);
+        this.stdout.end();
+        this.stderr.end();
+        this.emit("close", code, signal);
+    }
+    fail(error) {
+        if (this.closed)
+            return;
+        this.emit("error", error);
+        this.close(-1);
+    }
+    kill(signal = "SIGKILL") {
+        if (this.closed)
+            return false;
+        this.killed = true;
+        this.close(null, signal);
+        return true;
+    }
+}
+class AsyncInputQueue {
+    maxDepth;
+    items = [];
+    takers = [];
+    closed = false;
+    constructor(maxDepth = 32) {
+        this.maxDepth = maxDepth;
+    }
+    push(item) {
+        if (this.closed)
+            return Promise.reject(new Error("provider input stream is closed"));
+        if (this.items.length >= this.maxDepth) {
+            return Promise.reject(new Error(`provider input queue is full (${this.maxDepth})`));
+        }
+        const taker = this.takers.shift();
+        if (taker)
+            taker({ value: item, done: false });
+        else
+            this.items.push(item);
+        return Promise.resolve();
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const taker of this.takers.splice(0))
+            taker({ value: undefined, done: true });
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                const item = this.items.shift();
+                if (item !== undefined)
+                    return Promise.resolve({ value: item, done: false });
+                if (this.closed)
+                    return Promise.resolve({ value: undefined, done: true });
+                return new Promise((resolve) => this.takers.push(resolve));
+            },
+        };
+    }
+}
+function writeLine(stdin, payload) {
+    return new Promise((resolve, reject) => {
+        if (!stdin || stdin.destroyed) {
+            reject(new Error("provider input stream is closed"));
+            return;
+        }
+        const text = `${JSON.stringify(payload)}\n`;
+        const writable = stdin;
+        writable.write(text, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function userMessage(text) {
+    return {
+        type: "user",
+        message: { role: "user", content: text },
+        parent_tool_use_id: null,
+    };
+}
+function textInput(text) {
+    return { type: "text", text, text_elements: [] };
+}
+class MockJsonlDriver {
+    child;
+    provider;
+    process;
+    queue = Promise.resolve();
+    turn = 0;
+    constructor(child, provider) {
+        this.child = child;
+        this.provider = provider;
+        this.process = new LogicalProcess(child.pid);
+        child.once("spawn", () => this.process.emit("spawn"));
+        child.once("error", (err) => this.process.fail(err));
+        child.once("close", (code, signal) => {
+            if (!this.process.killed)
+                this.process.close(code, signal);
+        });
+        child.stdout?.on("data", (chunk) => this.process.stdout.write(chunk));
+        child.stderr?.on("data", (chunk) => this.process.stderr.write(chunk));
+        // Swallow stdin pipe errors (e.g. EPIPE writing to an exited child): the
+        // writeLine() callback already surfaces the failure; without this listener
+        // Node throws the socket's unhandled 'error' event and crashes the process.
+        child.stdin?.on("error", () => { });
+    }
+    get closed() {
+        return this.process.killed || this.child.killed || this.child.exitCode !== null;
+    }
+    start(message) {
+        return this.send(message);
+    }
+    send(message) {
+        const next = this.queue.then(async () => {
+            if (this.closed)
+                throw new Error("provider driver is closed");
+            this.turn += 1;
+            await writeLine(this.child.stdin, {
+                type: "turn.start",
+                provider: this.provider,
+                turn: this.turn,
+                message,
+            });
+        });
+        this.queue = next.catch(() => { });
+        return next;
+    }
+    kill() {
+        this.process.killed = true;
+        this.child.stdin?.destroy();
+        this.child.kill("SIGKILL");
+        this.process.kill("SIGKILL");
+    }
+}
+export class CodexAppServerDriver {
+    child;
+    options;
+    process;
+    pending = new Map();
+    queuedTurns = [];
+    nextId = 1;
+    stdoutBuf = "";
+    threadId = null;
+    activeTurnId = null;
+    drainActive = false;
+    initialized = false;
+    turnInFlight = false;
+    maxQueueDepth = 32;
+    constructor(child, options) {
+        this.child = child;
+        this.options = options;
+        this.process = new LogicalProcess(child.pid);
+        child.once("spawn", () => this.process.emit("spawn"));
+        child.once("error", (err) => this.fail(err));
+        child.once("close", (code, signal) => {
+            if (!this.process.killed)
+                this.process.close(code, signal);
+            this.rejectPending(new Error(`codex app-server exited before responding (code=${code ?? signal})`));
+        });
+        child.stdout?.on("data", (chunk) => this.onStdout(chunk.toString()));
+        child.stderr?.on("data", (chunk) => this.process.stderr.write(chunk));
+        // Swallow stdin pipe errors (e.g. EPIPE writing to an exited child): the
+        // writeLine() callback already surfaces the failure; without this listener
+        // Node throws the socket's unhandled 'error' event and crashes the process.
+        child.stdin?.on("error", () => { });
+    }
+    get closed() {
+        return this.process.killed || this.child.killed || this.child.exitCode !== null;
+    }
+    async start(message) {
+        await this.request("initialize", {
+            clientInfo: { name: "subagent-mcp", title: "subagent-mcp", version: "0.0.0" },
+            capabilities: null,
+        });
+        await this.notify("initialized");
+        const thread = await this.request("thread/start", {
+            model: this.options.model,
+            cwd: this.options.cwd,
+            approvalPolicy: "never",
+            sandbox: "danger-full-access",
+            ephemeral: true,
+            threadSource: "subagent",
+        });
+        this.threadId = String(thread.result?.thread?.id ?? "");
+        if (!this.threadId)
+            throw new Error("codex app-server thread/start returned no thread id");
+        this.initialized = true;
+        await this.startTurn(message);
+    }
+    send(message) {
+        if (this.closed)
+            return Promise.reject(new Error("provider driver is closed"));
+        if (!this.initialized || !this.threadId) {
+            return Promise.reject(new Error("codex app-server thread is not initialized"));
+        }
+        if (this.queuedTurns.length >= this.maxQueueDepth) {
+            return Promise.reject(new Error(`provider input queue is full (${this.maxQueueDepth})`));
+        }
+        this.queuedTurns.push(message);
+        void this.drainQueuedTurns();
+        return Promise.resolve();
+    }
+    kill() {
+        this.process.killed = true;
+        this.child.stdin?.destroy();
+        this.child.kill("SIGKILL");
+        this.process.kill("SIGKILL");
+        this.rejectPending(new Error("codex app-server driver was killed"));
+        this.queuedTurns.length = 0;
+    }
+    async drainQueuedTurns() {
+        if (this.drainActive)
+            return;
+        this.drainActive = true;
+        try {
+            while (!this.closed && !this.turnInFlight && this.queuedTurns.length > 0) {
+                const next = this.queuedTurns.shift();
+                if (next !== undefined)
+                    await this.startTurn(next);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.process.stderr.write(`[codex app-server driver] ${msg}\n`);
+            this.process.close(1);
+        }
+        finally {
+            this.drainActive = false;
+        }
+    }
+    async startTurn(message) {
+        if (this.closed)
+            throw new Error("provider driver is closed");
+        if (!this.threadId)
+            throw new Error("codex app-server thread is not initialized");
+        this.turnInFlight = true;
+        try {
+            const response = await this.request("turn/start", {
+                threadId: this.threadId,
+                input: [textInput(message)],
+                cwd: this.options.cwd,
+                model: this.options.model,
+                effort: this.options.effort,
+                approvalPolicy: "never",
+                sandboxPolicy: { type: "dangerFullAccess" },
+            });
+            const turn = response.result?.turn;
+            this.activeTurnId = typeof turn?.id === "string" ? turn.id : this.activeTurnId;
+        }
+        catch (error) {
+            this.turnInFlight = false;
+            throw error;
+        }
+    }
+    async request(method, params) {
+        const id = this.nextId++;
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`codex app-server request timed out: ${method}`));
+            }, 15000);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        await writeLine(this.child.stdin, { id, method, params });
+        return promise;
+    }
+    notify(method, params) {
+        return writeLine(this.child.stdin, params === undefined ? { method } : { method, params });
+    }
+    onStdout(chunk) {
+        this.stdoutBuf += chunk;
+        const lines = this.stdoutBuf.split("\n");
+        this.stdoutBuf = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            this.process.stdout.write(line.replace(/\r$/, "") + "\n");
+            this.handleProtocolLine(line);
+        }
+    }
+    handleProtocolLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id === "number" && this.pending.has(message.id)) {
+            const pending = this.pending.get(message.id);
+            this.pending.delete(message.id);
+            clearTimeout(pending.timer);
+            if (message.error && typeof message.error === "object") {
+                const err = message.error;
+                pending.reject(new Error(String(err.message ?? "codex app-server error")));
+            }
+            else {
+                pending.resolve(message);
+            }
+        }
+        if (message.method === "turn/started" && message.params && typeof message.params === "object") {
+            const turn = (message.params.turn ?? {});
+            if (typeof turn.id === "string")
+                this.activeTurnId = turn.id;
+        }
+        if (message.method === "turn/completed") {
+            this.activeTurnId = null;
+            this.turnInFlight = false;
+            void this.drainQueuedTurns();
+        }
+    }
+    fail(error) {
+        this.process.fail(error);
+        this.rejectPending(error);
+    }
+    rejectPending(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        this.turnInFlight = false;
+    }
+}
+export class ClaudeSdkDriver {
+    queryFn;
+    process = new LogicalProcess(undefined, true);
+    input = new AsyncInputQueue();
+    abortController = new AbortController();
+    queue = Promise.resolve();
+    queryHandle = null;
+    closedFlag = false;
+    constructor(queryFn) {
+        this.queryFn = queryFn;
+    }
+    get closed() {
+        return this.closedFlag || this.process.killed;
+    }
+    open(options) {
+        const sdkOptions = {
+            abortController: this.abortController,
+            cwd: options.cwd,
+            env: options.env,
+            model: options.model,
+            pathToClaudeCodeExecutable: options.command,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            tools: { type: "preset", preset: "claude_code" },
+            maxTurns: 50,
+            includePartialMessages: true,
+        };
+        if (options.effort !== "none" && options.effort !== "ultracode") {
+            sdkOptions.effort = options.effort;
+        }
+        if (options.ucSettingsPath)
+            sdkOptions.settings = options.ucSettingsPath;
+        const query = this.queryFn({ prompt: this.input, options: sdkOptions });
+        this.queryHandle = query;
+        void this.pump(query);
+    }
+    start(message) {
+        return this.send(message);
+    }
+    send(message) {
+        const next = this.queue.then(() => {
+            if (this.closed)
+                throw new Error("provider driver is closed");
+            return this.input.push(userMessage(message));
+        });
+        this.queue = next.catch(() => { });
+        return next;
+    }
+    kill() {
+        if (this.closedFlag)
+            return;
+        this.closedFlag = true;
+        this.input.close();
+        this.abortController.abort();
+        this.queryHandle?.close?.();
+        this.process.kill("SIGKILL");
+    }
+    async pump(query) {
+        try {
+            for await (const message of query) {
+                this.process.stdout.write(`${JSON.stringify(message)}\n`);
+            }
+            this.closedFlag = true;
+            this.process.close(0);
+        }
+        catch (error) {
+            if (!this.process.killed) {
+                this.closedFlag = true;
+                this.process.stderr.write(error instanceof Error ? error.message : String(error));
+                this.process.close(1);
+            }
+        }
+    }
+}
+export async function createProviderDriver(options) {
+    if ((options.provider === "claude" && process.env.SUBAGENT_MOCK_CLAUDE_DRIVER === "jsonl") ||
+        (options.provider === "codex" && process.env.SUBAGENT_MOCK_CODEX_DRIVER === "jsonl")) {
+        const mockScript = process.env.SUBAGENT_MOCK_DRIVER_SCRIPT;
+        const child = mockScript
+            ? spawn(process.execPath, [mockScript, options.provider], {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            })
+            : spawn(options.command, [], {
+                cwd: options.cwd,
+                env: options.env,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+        return new MockJsonlDriver(child, options.provider);
+    }
+    if (options.provider === "claude") {
+        let sdk;
+        try {
+            sdk = (await import("@anthropic-ai/claude-agent-sdk"));
+        }
+        catch {
+            throw new Error("Claude interactive driver requires @anthropic-ai/claude-agent-sdk; no one-shot CLI fallback is available");
+        }
+        if (typeof sdk.query !== "function") {
+            throw new Error("Claude Agent SDK does not expose the query() streaming API");
+        }
+        const driver = new ClaudeSdkDriver(sdk.query);
+        driver.open(options);
+        return driver;
+    }
+    const child = spawn(options.command, options.args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    return new CodexAppServerDriver(child, options);
+}

package/dist/effort.js

@@ -38,11 +38,11 @@ export function resolveEffort(provider, model, effort) {
     }
     return { kind: "flag", value: "high" };
 }
-export function buildCommand(provider, model, effort, prompt, cwd) {
+export function buildCommand(provider, model, effort, cwd) {
     const mapped = mapModel(provider, model);
     const er = resolveEffort(provider, model, effort);
     if (provider === "claude") {
-        const args = ["-p", "--model", mapped];
+        const args = ["--model", mapped];
         if (er.kind === "flag") {
             args.push("--effort", er.value);
         }
@@ -50,28 +50,19 @@ export function buildCommand(provider, model, effort, prompt, cwd) {
             const ucSettingsPath = join(tmpdir(), `subagent-uc-${randomUUID()}.json`);
             writeFileSync(ucSettingsPath, '{"ultracode":true}');
             args.push("--settings", ucSettingsPath);
-            args.push("--permission-mode", "bypassPermissions", "--tools", "default", "--max-turns", "50", "--output-format", "stream-json", "--verbose");
+            args.push("--permission-mode", "bypassPermissions", "--tools", "default", "--max-turns", "50");
             return { args, ucSettingsPath };
         }
-        args.push("--permission-mode", "bypassPermissions", "--tools", "default", "--max-turns", "50", "--output-format", "stream-json", "--verbose");
+        args.push("--permission-mode", "bypassPermissions", "--tools", "default", "--max-turns", "50");
         return { args };
     }
     else {
         // codex
-        const effortValue = er.value;
+        void er.value;
         return {
             args: [
-                "exec",
-                "-C",
-                cwd,
-                "-m",
-                "gpt-5.5",
-                "-c",
-                `model_reasoning_effort="${effortValue}"`,
-                "--dangerously-bypass-approvals-and-sandbox",
-                "--skip-git-repo-check",
-                "--json",
-                prompt,
+                "app-server",
+                "--stdio",
             ],
         };
     }

package/dist/hooks/orchestration-claude.js

@@ -43,7 +43,8 @@ export const claudeAdapter = {
         return countJsonlType(transcriptPath, "user");
     },
     fullDirectiveFile: "orchestration-claude.md",
-    offTurnFile: "off-turn-reminder.md",
+    shortOnFile: "short-on.md",
+    shortOffFile: "short-off.md",
     carryoverDirectiveFile: "carryover-claude.md",
     reminderOnFile: "reminder-on.md",
     reminderOffFile: "reminder-off-claude.md",

package/dist/hooks/orchestration-codex.js

@@ -58,7 +58,8 @@ export const codexAdapter = {
         return countJsonlType(transcriptPath, "turn_context");
     },
     fullDirectiveFile: "orchestration-codex.md",
-    offTurnFile: "off-turn-reminder.md",
+    shortOnFile: "short-on.md",
+    shortOffFile: "short-off.md",
     carryoverDirectiveFile: "carryover-codex.md",
     reminderOnFile: "reminder-on.md",
     reminderOffFile: "reminder-off-codex.md",