@thinkwell/conductor 0.5.5 → 0.5.6

package/dist/connectors/channel.js

@@ -1,155 +1,88 @@
-/**
- * ChannelConnector - in-memory bidirectional connection
- *
- * This connector creates an in-memory channel for testing or for
- * embedded components that run in the same process.
- */
-/**
- * A simple message channel that supports async iteration
- */
 class MessageChannel {
-    queue = [];
-    resolvers = [];
-    closed = false;
-    push(message) {
-        if (this.closed) {
-            return;
-        }
-        if (this.resolvers.length > 0) {
-            const resolve = this.resolvers.shift();
-            resolve(message);
-        }
-        else {
-            this.queue.push(message);
-        }
-    }
-    close() {
-        this.closed = true;
-        for (const resolve of this.resolvers) {
-            resolve(null);
-        }
-        this.resolvers = [];
-    }
-    isClosed() {
-        return this.closed;
-    }
-    async *[Symbol.asyncIterator]() {
-        while (!this.closed) {
-            let message;
-            if (this.queue.length > 0) {
-                message = this.queue.shift();
-            }
-            else {
-                message = await new Promise((resolve) => {
-                    this.resolvers.push(resolve);
-                });
-            }
-            if (message === null) {
-                return;
-            }
-            yield message;
-        }
-        // Drain any remaining messages
-        while (this.queue.length > 0) {
-            yield this.queue.shift();
-        }
+  queue = [];
+  resolvers = [];
+  closed = !1;
+  push(message) {
+    this.closed || (this.resolvers.length > 0 ? this.resolvers.shift()(message) : this.queue.push(message));
+  }
+  close() {
+    this.closed = !0;
+    for (const resolve of this.resolvers)
+      resolve(null);
+    this.resolvers = [];
+  }
+  isClosed() {
+    return this.closed;
+  }
+  async *[Symbol.asyncIterator]() {
+    for (; !this.closed; ) {
+      let message;
+      if (this.queue.length > 0 ? message = this.queue.shift() : message = await new Promise((resolve) => {
+        this.resolvers.push(resolve);
+      }), message === null)
+        return;
+      yield message;
     }
+    for (; this.queue.length > 0; )
+      yield this.queue.shift();
+  }
 }
-/**
- * One side of a channel connection
- */
 class ChannelConnectionEnd {
-    sendChannel;
-    receiveChannel;
-    constructor(sendChannel, receiveChannel) {
-        this.sendChannel = sendChannel;
-        this.receiveChannel = receiveChannel;
-    }
-    send(message) {
-        this.sendChannel.push(message);
-    }
-    get messages() {
-        return this.receiveChannel;
-    }
-    async close() {
-        this.sendChannel.close();
-        this.receiveChannel.close();
-    }
+  sendChannel;
+  receiveChannel;
+  constructor(sendChannel, receiveChannel) {
+    this.sendChannel = sendChannel, this.receiveChannel = receiveChannel;
+  }
+  send(message) {
+    this.sendChannel.push(message);
+  }
+  get messages() {
+    return this.receiveChannel;
+  }
+  async close() {
+    this.sendChannel.close(), this.receiveChannel.close();
+  }
 }
-/**
- * Create a connected pair of channel endpoints.
- *
- * This is useful for testing or for connecting in-process components.
- */
 export function createChannelPair() {
-    const leftToRight = new MessageChannel();
-    const rightToLeft = new MessageChannel();
-    return {
-        left: new ChannelConnectionEnd(leftToRight, rightToLeft),
-        right: new ChannelConnectionEnd(rightToLeft, leftToRight),
-    };
+  const leftToRight = new MessageChannel(), rightToLeft = new MessageChannel();
+  return {
+    left: new ChannelConnectionEnd(leftToRight, rightToLeft),
+    right: new ChannelConnectionEnd(rightToLeft, leftToRight)
+  };
 }
-/**
- * Connector for in-memory channel connections.
- *
- * Each call to connect() returns a new channel pair. The "other" end
- * must be retrieved via getOtherEnd() after calling connect().
- */
 export class ChannelConnector {
-    pendingOtherEnd = null;
-    async connect() {
-        const pair = createChannelPair();
-        this.pendingOtherEnd = pair.right;
-        return pair.left;
-    }
-    /**
-     * Get the other end of the most recently created channel.
-     *
-     * This must be called after connect() to get the paired endpoint.
-     */
-    getOtherEnd() {
-        const end = this.pendingOtherEnd;
-        this.pendingOtherEnd = null;
-        return end;
-    }
+  pendingOtherEnd = null;
+  async connect() {
+    const pair = createChannelPair();
+    return this.pendingOtherEnd = pair.right, pair.left;
+  }
+  /**
+   * Get the other end of the most recently created channel.
+   *
+   * This must be called after connect() to get the paired endpoint.
+   */
+  getOtherEnd() {
+    const end = this.pendingOtherEnd;
+    return this.pendingOtherEnd = null, end;
+  }
 }
-/**
- * Create a connector that runs a handler function in-process.
- *
- * This is useful for testing or for embedding simple components.
- *
- * @param handler - Function that handles the component side of the connection
- * @returns A connector that runs the handler when connect() is called
- */
 export function inProcess(handler) {
-    return {
-        async connect() {
-            const pair = createChannelPair();
-            // Start the handler on the other end (don't await it)
-            handler(pair.right).catch((error) => {
-                console.error("In-process component error:", error);
-            });
-            return pair.left;
-        },
-    };
+  return {
+    async connect() {
+      const pair = createChannelPair();
+      return handler(pair.right).catch((error) => {
+        console.error("In-process component error:", error);
+      }), pair.left;
+    }
+  };
 }
-/**
- * Create a simple echo component for testing.
- *
- * This component echoes back any request with the same params as the result.
- */
 export function echoComponent() {
-    return inProcess(async (connection) => {
-        for await (const message of connection.messages) {
-            if ("method" in message && "id" in message) {
-                // It's a request - echo the params back as the result
-                connection.send({
-                    jsonrpc: "2.0",
-                    id: message.id,
-                    result: message.params,
-                });
-            }
-        }
-    });
+  return inProcess(async (connection) => {
+    for await (const message of connection.messages)
+      "method" in message && "id" in message && connection.send({
+        jsonrpc: "2.0",
+        id: message.id,
+        result: message.params
+      });
+  });
 }
-//# sourceMappingURL=channel.js.map

package/dist/connectors/index.js

@@ -1,6 +1,2 @@
-/**
- * Component connectors - factories for creating component connections
- */
 export { StdioConnector, stdio } from "./stdio.js";
-export { ChannelConnector, createChannelPair, inProcess, echoComponent, } from "./channel.js";
-//# sourceMappingURL=index.js.map
+export { ChannelConnector, createChannelPair, inProcess, echoComponent } from "./channel.js";

package/dist/connectors/stdio.js

@@ -1,214 +1,112 @@
-/**
- * StdioConnector - spawns a subprocess and communicates via stdin/stdout
- *
- * This connector starts a child process and establishes a bidirectional
- * JSON-RPC connection using newline-delimited JSON over stdio.
- */
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-/**
- * A connection to a subprocess via stdin/stdout
- */
 class StdioConnection {
-    process;
-    readline;
-    closed = false;
-    closingGracefully = false;
-    constructor(process) {
-        this.process = process;
-        if (!process.stdout || !process.stdin) {
-            throw new Error("Process must have stdio pipes");
-        }
-        // Set up readline for reading newline-delimited JSON
-        this.readline = createInterface({
-            input: process.stdout,
-            crlfDelay: Infinity,
-        });
-        // Handle process exit
-        process.on("exit", (code, signal) => {
-            this.closed = true;
-            // Don't log exit codes during graceful shutdown - we expect non-zero codes
-            // when we send SIGTERM/SIGKILL to processes that don't handle stdin EOF.
-            // This is a workaround for kiro-cli acp (v1.25.0) which doesn't exit on stdin close.
-            if (code !== 0 && code !== null && !this.closingGracefully) {
-                console.error(`Process exited with code ${code}`);
-            }
-            // Only log signal if it wasn't an expected graceful shutdown
-            if (signal && !this.closingGracefully) {
-                console.error(`Process killed by signal ${signal}`);
-            }
-        });
-        process.on("error", (error) => {
-            console.error("Process error:", error);
-            this.closed = true;
-        });
-    }
-    /**
-     * Send a JSON-RPC message to the subprocess
-     */
-    send(message) {
-        if (this.closed || !this.process.stdin) {
-            throw new Error("Connection is closed");
-        }
-        const json = JSON.stringify(message);
-        this.process.stdin.write(json + "\n");
-    }
-    /**
-     * Async iterable of messages received from the subprocess
-     */
-    get messages() {
-        const readline = this.readline;
-        const isClosed = () => this.closed;
-        return {
-            async *[Symbol.asyncIterator]() {
-                for await (const line of readline) {
-                    if (isClosed()) {
-                        return;
-                    }
-                    if (!line.trim()) {
-                        continue;
-                    }
-                    try {
-                        const message = JSON.parse(line);
-                        yield message;
-                    }
-                    catch (error) {
-                        console.error("Failed to parse JSON-RPC message:", error);
-                        console.error("Line:", line);
-                    }
-                }
-            },
-        };
-    }
-    /**
-     * Close the connection and terminate the subprocess
-     */
-    async close() {
-        if (this.closed) {
+  process;
+  readline;
+  closed = !1;
+  closingGracefully = !1;
+  constructor(process) {
+    if (this.process = process, !process.stdout || !process.stdin)
+      throw new Error("Process must have stdio pipes");
+    this.readline = createInterface({
+      input: process.stdout,
+      crlfDelay: 1 / 0
+    }), process.on("exit", (code, signal) => {
+      this.closed = !0, code !== 0 && code !== null && !this.closingGracefully && console.error(`Process exited with code ${code}`), signal && !this.closingGracefully && console.error(`Process killed by signal ${signal}`);
+    }), process.on("error", (error) => {
+      console.error("Process error:", error), this.closed = !0;
+    });
+  }
+  /**
+   * Send a JSON-RPC message to the subprocess
+   */
+  send(message) {
+    if (this.closed || !this.process.stdin)
+      throw new Error("Connection is closed");
+    const json = JSON.stringify(message);
+    this.process.stdin.write(json + `
+`);
+  }
+  /**
+   * Async iterable of messages received from the subprocess
+   */
+  get messages() {
+    const readline = this.readline, isClosed = () => this.closed;
+    return {
+      async *[Symbol.asyncIterator]() {
+        for await (const line of readline) {
+          if (isClosed())
             return;
+          if (line.trim())
+            try {
+              yield JSON.parse(line);
+            } catch (error) {
+              console.error("Failed to parse JSON-RPC message:", error), console.error("Line:", line);
+            }
         }
-        this.closed = true;
-        this.closingGracefully = true;
-        // Close the readline interface
-        this.readline.close();
-        // Close the stdout stream to release the pipe handle
-        this.process.stdout?.destroy();
-        // Close stdin to signal EOF to the subprocess
-        this.process.stdin?.end();
-        // Wait for the process to exit gracefully, with fallback to signals
-        // Note: Some processes don't properly handle stdin EOF and need explicit signals.
-        // For example, kiro-cli acp (as of v1.25.0) doesn't exit on stdin close.
-        await new Promise((resolve) => {
-            let sigtermTimeout = null;
-            let sigkillTimeout = null;
-            const onExit = () => {
-                if (sigtermTimeout)
-                    clearTimeout(sigtermTimeout);
-                if (sigkillTimeout)
-                    clearTimeout(sigkillTimeout);
-                resolve();
-            };
-            this.process.once("exit", onExit);
-            // Wait 250ms for graceful exit, then send SIGTERM
-            sigtermTimeout = setTimeout(() => {
-                this.process.kill("SIGTERM");
-                // Wait another 500ms, then force kill with SIGKILL
-                sigkillTimeout = setTimeout(() => {
-                    this.process.kill("SIGKILL");
-                    resolve();
-                }, 500);
-            }, 250);
-        });
-    }
+      }
+    };
+  }
+  /**
+   * Close the connection and terminate the subprocess
+   */
+  async close() {
+    this.closed || (this.closed = !0, this.closingGracefully = !0, this.readline.close(), this.process.stdout?.destroy(), this.process.stdin?.end(), await new Promise((resolve) => {
+      let sigtermTimeout = null, sigkillTimeout = null;
+      const onExit = () => {
+        sigtermTimeout && clearTimeout(sigtermTimeout), sigkillTimeout && clearTimeout(sigkillTimeout), resolve();
+      };
+      this.process.once("exit", onExit), sigtermTimeout = setTimeout(() => {
+        this.process.kill("SIGTERM"), sigkillTimeout = setTimeout(() => {
+          this.process.kill("SIGKILL"), resolve();
+        }, 500);
+      }, 250);
+    }));
+  }
 }
-/**
- * Connector that spawns a subprocess and communicates via stdio
- */
 export class StdioConnector {
-    options;
-    constructor(options) {
-        if (typeof options === "string") {
-            // Parse command string (split on whitespace, respecting quotes)
-            const parts = parseCommand(options);
-            this.options = {
-                command: parts[0],
-                args: parts.slice(1),
-            };
-        }
-        else {
-            this.options = options;
-        }
-    }
-    /**
-     * Spawn the subprocess and return a connection to it
-     */
-    async connect() {
-        const { command, args = [], env, cwd } = this.options;
-        const process = spawn(command, args, {
-            stdio: ["pipe", "pipe", "inherit"], // stdin, stdout piped; stderr inherited
-            env: env ? { ...globalThis.process.env, ...env } : undefined,
-            cwd,
-        });
-        // Wait for the process to spawn successfully
-        await new Promise((resolve, reject) => {
-            const onSpawn = () => {
-                cleanup();
-                resolve();
-            };
-            const onError = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const cleanup = () => {
-                process.removeListener("spawn", onSpawn);
-                process.removeListener("error", onError);
-            };
-            process.once("spawn", onSpawn);
-            process.once("error", onError);
-        });
-        return new StdioConnection(process);
-    }
+  options;
+  constructor(options) {
+    if (typeof options == "string") {
+      const parts = parseCommand(options);
+      this.options = {
+        command: parts[0],
+        args: parts.slice(1)
+      };
+    } else
+      this.options = options;
+  }
+  /**
+   * Spawn the subprocess and return a connection to it
+   */
+  async connect() {
+    const { command, args = [], env, cwd } = this.options, process = spawn(command, args, {
+      stdio: ["pipe", "pipe", "inherit"],
+      // stdin, stdout piped; stderr inherited
+      env: env ? { ...globalThis.process.env, ...env } : void 0,
+      cwd
+    });
+    return await new Promise((resolve, reject) => {
+      const onSpawn = () => {
+        cleanup(), resolve();
+      }, onError = (error) => {
+        cleanup(), reject(error);
+      }, cleanup = () => {
+        process.removeListener("spawn", onSpawn), process.removeListener("error", onError);
+      };
+      process.once("spawn", onSpawn), process.once("error", onError);
+    }), new StdioConnection(process);
+  }
 }
-/**
- * Parse a command string into command and arguments.
- * Handles quoted strings.
- */
 function parseCommand(command) {
-    const parts = [];
-    let current = "";
-    let inQuote = null;
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if (inQuote) {
-            if (char === inQuote) {
-                inQuote = null;
-            }
-            else {
-                current += char;
-            }
-        }
-        else if (char === '"' || char === "'") {
-            inQuote = char;
-        }
-        else if (char === " " || char === "\t") {
-            if (current) {
-                parts.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        parts.push(current);
-    }
-    return parts;
+  const parts = [];
+  let current = "", inQuote = null;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    inQuote ? char === inQuote ? inQuote = null : current += char : char === '"' || char === "'" ? inQuote = char : char === " " || char === "	" ? current && (parts.push(current), current = "") : current += char;
+  }
+  return current && parts.push(current), parts;
 }
-/**
- * Create a StdioConnector from a command string or options
- */
 export function stdio(options) {
-    return new StdioConnector(options);
+  return new StdioConnector(options);
 }
-//# sourceMappingURL=stdio.js.map

package/dist/generated/features.d.ts

@@ -0,0 +1,5 @@
+export declare const features: {
+    readonly LOG_PERMISSIONS: false;
+    readonly STRIP_CLAUDECODE_ENV: false;
+};
+//# sourceMappingURL=features.d.ts.map

package/dist/generated/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../src/generated/features.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ;;;CAGX,CAAC"}

package/dist/generated/features.js

@@ -0,0 +1,4 @@
+export const features = {
+  LOG_PERMISSIONS: !1,
+  STRIP_CLAUDECODE_ENV: !1
+};

package/dist/generated/features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.js","sourceRoot":"","sources":["../../src/generated/features.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,eAAe,EAAE,KAAK;IACtB,oBAAoB,EAAE,KAAK;CACnB,CAAC"}

package/dist/index.js

@@ -1,76 +1,8 @@
-/**
- * @thinkwell/conductor - TypeScript conductor for ACP proxy chains
- *
- * The conductor orchestrates message routing between clients, proxies, and agents.
- * It sits between every component, managing process lifecycle and message flow.
- *
- * ## Quick Start
- *
- * ```typescript
- * import { Conductor, fromCommands, createChannelPair } from '@thinkwell/conductor';
- *
- * // Create a conductor that spawns an agent subprocess
- * const conductor = new Conductor({
- *   instantiator: fromCommands(['my-agent']),
- * });
- *
- * // Connect via a channel (for testing) or stdio (for production)
- * const [clientEnd, conductorEnd] = createChannelPair();
- * await conductor.connect(conductorEnd);
- * ```
- *
- * ## Logging
- *
- * Enable logging to see what the conductor is doing:
- *
- * ```typescript
- * const conductor = new Conductor({
- *   instantiator: fromCommands(['my-agent']),
- *   logging: {
- *     level: 'debug', // 'error' | 'warn' | 'info' | 'debug' | 'trace'
- *     name: 'my-app',
- *   },
- * });
- * ```
- *
- * ## JSONL Tracing
- *
- * Write all messages to a JSONL file for debugging:
- *
- * ```typescript
- * const conductor = new Conductor({
- *   instantiator: fromCommands(['my-agent']),
- *   trace: {
- *     path: '/tmp/conductor-trace.jsonl',
- *   },
- * });
- * ```
- *
- * ## Architecture
- *
- * The conductor uses a central message queue to preserve ordering:
- *
- * ```
- * Client ←→ Conductor ←→ [Proxy 0] ←→ [Proxy 1] ←→ ... ←→ Agent
- * ```
- *
- * All messages flow through the conductor's event loop, ensuring that
- * responses never overtake notifications.
- *
- * @module
- */
-// Conductor
 export { Conductor } from "./conductor.js";
-// Logging
-export { createLogger, createNoopLogger, getLogger, setLogger, } from "./logger.js";
-// Instantiators
-export { fromCommands, fromConnectors, dynamic, staticInstantiator, } from "./instantiators.js";
+export { createLogger, createNoopLogger, getLogger, setLogger } from "./logger.js";
+export { fromCommands, fromConnectors, dynamic, staticInstantiator } from "./instantiators.js";
 export { ROLE_COUNTERPART } from "./types.js";
-// Message queue
 export { MessageQueue } from "./message-queue.js";
-// Connectors
-export { StdioConnector, stdio, ChannelConnector, createChannelPair, inProcess, echoComponent, } from "./connectors/index.js";
-// MCP Bridge
-export { McpBridge, createHttpListener, } from "./mcp-bridge/index.js";
-export { isJsonRpcRequest, isJsonRpcNotification, isJsonRpcResponse, createRequest, createNotification, createSuccessResponse, createErrorResponse, createResponder, } from "@thinkwell/protocol";
-//# sourceMappingURL=index.js.map
+export { StdioConnector, stdio, ChannelConnector, createChannelPair, inProcess, echoComponent } from "./connectors/index.js";
+export { McpBridge, createHttpListener } from "./mcp-bridge/index.js";
+export { isJsonRpcRequest, isJsonRpcNotification, isJsonRpcResponse, createRequest, createNotification, createSuccessResponse, createErrorResponse, createResponder } from "@thinkwell/protocol";