@moxxy/cli 0.0.8 → 0.0.10

package/dist/src-WIOCZRAC.mjs

@@ -0,0 +1,1397 @@
+import "./chunk-6DZX6EAA.mjs";
+
+// ../claude/src/events/emitter.ts
+var TypedEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to an event with type-safe handler
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    const onceHandler = ((...args) => {
+      this.off(event, onceHandler);
+      handler(...args);
+    });
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+      if (eventHandlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+    return this;
+  }
+  /**
+   * Emit an event with type-safe arguments
+   */
+  emit(event, ...args) {
+    const eventHandlers = this.handlers.get(event);
+    if (!eventHandlers || eventHandlers.size === 0) {
+      return false;
+    }
+    eventHandlers.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for '${event}':`, error);
+      }
+    });
+    return true;
+  }
+  /**
+   * Remove all handlers for an event or all events
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+    return this;
+  }
+  /**
+   * Get the number of listeners for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /**
+   * Get all registered event names
+   */
+  eventNames() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Wait for an event to occur (promisified)
+   */
+  waitFor(event, timeout) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      const handler = ((...args) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve(args);
+      });
+      this.once(event, handler);
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          this.off(event, handler);
+          reject(new Error(`Timeout waiting for event '${event}'`));
+        }, timeout);
+      }
+    });
+  }
+};
+function createEventEmitter() {
+  return new TypedEventEmitter();
+}
+
+// ../claude/src/modules/base.ts
+var BaseModule = class {
+  constructor(transport, events) {
+    this.transport = transport;
+    this.events = events;
+  }
+  /**
+   * Make a request through the transport
+   */
+  async request(method, params) {
+    return this.transport.request(method, params);
+  }
+};
+
+// ../claude/src/errors/errors.ts
+var ClaudeError = class extends Error {
+  code;
+  details;
+  cause;
+  constructor(message, code, details, cause) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message
+      } : void 0
+    };
+  }
+};
+var CLIError = class extends ClaudeError {
+  exitCode;
+  stdout;
+  stderr;
+  constructor(message, exitCode, stdout, stderr, cause) {
+    super(message, "CLI_ERROR", { exitCode, stdout, stderr }, cause);
+    this.exitCode = exitCode;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+var ProcessError = class extends ClaudeError {
+  processId;
+  constructor(message, processId, details, cause) {
+    super(
+      message,
+      "PROCESS_ERROR",
+      { processId, ...details && typeof details === "object" ? details : {} },
+      cause
+    );
+    this.processId = processId;
+  }
+};
+var StreamParseError = class extends ClaudeError {
+  line;
+  constructor(message, line, cause) {
+    super(message, "STREAM_PARSE_ERROR", { line }, cause);
+    this.line = line;
+  }
+};
+var ConnectionError = class extends ClaudeError {
+  constructor(message, details, cause) {
+    super(message, "CONNECTION_ERROR", details, cause);
+  }
+};
+var TimeoutError = class extends ClaudeError {
+  timeout;
+  constructor(message, timeout) {
+    super(message, "TIMEOUT_ERROR", { timeout });
+    this.timeout = timeout;
+  }
+};
+var ValidationError = class extends ClaudeError {
+  field;
+  constructor(message, field, details) {
+    super(
+      message,
+      "VALIDATION_ERROR",
+      { field, ...details && typeof details === "object" ? details : {} }
+    );
+    this.field = field;
+  }
+};
+var NotFoundError = class extends ClaudeError {
+  resource;
+  identifier;
+  constructor(resource, identifier) {
+    super(`${resource} not found: ${identifier}`, "NOT_FOUND", { resource, identifier });
+    this.resource = resource;
+    this.identifier = identifier;
+  }
+};
+var NotConnectedError = class extends ClaudeError {
+  constructor(message = "SDK not connected") {
+    super(message, "NOT_CONNECTED");
+  }
+};
+var NotImplementedError = class extends ClaudeError {
+  constructor(feature) {
+    super(`Feature not implemented: ${feature}`, "NOT_IMPLEMENTED", { feature });
+  }
+};
+
+// ../claude/src/modules/agents.ts
+var AgentsModule = class extends BaseModule {
+  /**
+   * List agents
+   * Returns a single stub agent since Claude CLI doesn't have multiple agents
+   */
+  async list() {
+    return this.request("agents.list");
+  }
+  /**
+   * Get agent by ID
+   * Returns stub agent data
+   */
+  async get(agentId) {
+    return this.request("agents.get", { agentId });
+  }
+  /**
+   * Create agent
+   * Not supported - Claude CLI agents are not managed this way
+   */
+  async create() {
+    throw new NotImplementedError("Agent creation not supported with Claude CLI");
+  }
+  /**
+   * Update agent
+   * Not supported - Claude CLI agents are not managed this way
+   */
+  async update() {
+    throw new NotImplementedError("Agent updates not supported with Claude CLI");
+  }
+  /**
+   * Delete agent
+   * Not supported - Claude CLI agents are not managed this way
+   */
+  async delete() {
+    throw new NotImplementedError("Agent deletion not supported with Claude CLI");
+  }
+  /**
+   * Set agent identity
+   * Not supported - Claude CLI manages identity
+   */
+  async setIdentity() {
+    throw new NotImplementedError("Agent identity changes not supported with Claude CLI");
+  }
+  /**
+   * Set agent model
+   * Not supported - Model is set per-session in Claude CLI
+   */
+  async setModel() {
+    throw new NotImplementedError("Agent model changes not supported with Claude CLI. Use SDK config instead.");
+  }
+};
+
+// ../claude/src/parsers/stream-parser.ts
+import { createInterface } from "readline";
+var ClaudeStreamParser = class {
+  sessionKey;
+  constructor(sessionKey) {
+    this.sessionKey = sessionKey;
+  }
+  /**
+   * Parse a single line of JSON stream output
+   */
+  parseLine(line) {
+    if (!line.trim()) {
+      return null;
+    }
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Convert stream event to chat stream chunk
+   * Handles both CLI format and API format events
+   */
+  toChunk(event) {
+    switch (event.type) {
+      // --- Claude CLI format events ---
+      case "assistant": {
+        const message = event.message;
+        if (!message?.content) return null;
+        const textBlocks = message.content.filter((b) => b.type === "text");
+        const text = textBlocks.map((b) => b.text || "").join("");
+        const thinkingBlocks = message.content.filter((b) => b.type === "thinking");
+        const thinking = thinkingBlocks.length > 0 ? thinkingBlocks.map((b) => b.thinking || b.text || "").join("") : void 0;
+        if (!text && !thinking) return null;
+        return {
+          content: text,
+          thinking,
+          done: false,
+          sessionKey: this.sessionKey,
+          timestamp: Date.now()
+        };
+      }
+      case "result": {
+        const resultText = event.result || "";
+        return {
+          content: resultText,
+          done: true,
+          sessionKey: this.sessionKey,
+          timestamp: Date.now()
+        };
+      }
+      case "system":
+        return null;
+      // --- Anthropic API format events (legacy/fallback) ---
+      case "content_block_delta": {
+        const text = event.delta?.text || "";
+        return {
+          content: text,
+          done: false,
+          sessionKey: this.sessionKey,
+          timestamp: Date.now()
+        };
+      }
+      case "thinking_block": {
+        return {
+          content: "",
+          thinking: event.content || "",
+          done: false,
+          sessionKey: this.sessionKey,
+          timestamp: Date.now()
+        };
+      }
+      case "message_stop": {
+        return {
+          content: "",
+          done: true,
+          sessionKey: this.sessionKey,
+          timestamp: Date.now()
+        };
+      }
+      case "content_block_start":
+      case "content_block_stop":
+      case "session_start":
+      case "message_start":
+        return null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Parse stream asynchronously
+   */
+  async *parseStream(stream) {
+    const reader = createInterface({
+      input: stream,
+      crlfDelay: Number.POSITIVE_INFINITY
+    });
+    try {
+      for await (const line of reader) {
+        const event = this.parseLine(line);
+        if (event) {
+          const chunk = this.toChunk(event);
+          if (chunk) {
+            yield chunk;
+            if (chunk.done) {
+              break;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new StreamParseError("Error parsing stream", "", error);
+      }
+      throw error;
+    } finally {
+      reader.close();
+    }
+  }
+  /**
+   * Collect full response from stream
+   * Returns full text and optional thinking
+   */
+  async collectFullResponse(stream) {
+    let fullContent = "";
+    let thinking;
+    for await (const chunk of this.parseStream(stream)) {
+      if (chunk.content) {
+        fullContent += chunk.content;
+      }
+      if (chunk.thinking) {
+        thinking = chunk.thinking;
+      }
+    }
+    return { content: fullContent, thinking };
+  }
+};
+
+// ../claude/src/modules/chat.ts
+var ChatModule = class extends BaseModule {
+  /**
+   * Send a message and wait for complete response
+   */
+  async send(options) {
+    return this.request("chat.send", options);
+  }
+  /**
+   * Send a message with streaming response
+   */
+  async *sendStream(options) {
+    const sessionKey = options.sessionKey || `claude-stream-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const agentId = options.agentId || "claude";
+    const transport = this.transport;
+    const sessionManager = transport.getSessionManager();
+    const processManager = transport.getProcessManager();
+    const session = sessionManager.getOrCreateSession(sessionKey, agentId);
+    sessionManager.addMessage(sessionKey, {
+      role: "user",
+      content: options.message,
+      timestamp: Date.now()
+    });
+    this.events.emit("chat:stream:start", sessionKey, agentId);
+    options.onStart?.(sessionKey, agentId);
+    const existingProc = processManager.get(sessionKey);
+    if (existingProc) {
+      processManager.kill(sessionKey);
+    }
+    const proc = await processManager.spawn({
+      sessionKey,
+      model: transport.config.model,
+      thinking: options.thinking,
+      permissionMode: transport.config.permissionMode,
+      workingDirectory: transport.config.workingDirectory,
+      timeout: options.timeout,
+      message: options.message,
+      outputFormat: "stream-json"
+    });
+    processManager.setStatus(sessionKey, "busy");
+    let fullResponse = "";
+    let thinking;
+    try {
+      const parser = new ClaudeStreamParser(sessionKey);
+      for await (const chunk of parser.parseStream(proc.process.stdout)) {
+        if (chunk.content) {
+          fullResponse += chunk.content;
+        }
+        if (chunk.thinking) {
+          thinking = chunk.thinking;
+        }
+        this.events.emit("chat:stream", chunk);
+        options.onChunk?.(chunk);
+        yield chunk;
+        if (chunk.done) {
+          break;
+        }
+      }
+      sessionManager.addMessage(sessionKey, {
+        role: "assistant",
+        content: fullResponse,
+        thinking,
+        timestamp: Date.now()
+      });
+      processManager.setStatus(sessionKey, "idle");
+      processManager.touch(sessionKey);
+      this.events.emit("chat:stream:end", sessionKey, agentId);
+      options.onEnd?.(sessionKey, agentId);
+      return {
+        sessionKey,
+        agentId,
+        response: fullResponse,
+        thinking,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      processManager.setStatus(sessionKey, "error");
+      throw error;
+    }
+  }
+  /**
+   * Get chat history for a session
+   */
+  async history(sessionKey, options) {
+    return this.request("sessions.history", { sessionKey, ...options });
+  }
+};
+
+// ../claude/src/modules/sessions.ts
+var SessionsModule = class extends BaseModule {
+  /**
+   * List sessions with optional filtering
+   */
+  async list(options) {
+    return this.request("sessions.list", options);
+  }
+  /**
+   * Get session details
+   */
+  async get(sessionKey) {
+    return this.request("sessions.get", { sessionKey });
+  }
+  /**
+   * Delete a session
+   */
+  async delete(sessionKey) {
+    await this.request("sessions.delete", { sessionKey });
+  }
+  /**
+   * Get session message history
+   */
+  async history(sessionKey, options) {
+    return this.request("sessions.history", { sessionKey, ...options });
+  }
+  /**
+   * Create a new session (convenience method)
+   * Sessions are created automatically on first message, but this can be used to pre-create
+   */
+  async create(agentId = "claude") {
+    const sessionKey = `claude-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    return { sessionKey };
+  }
+};
+
+// ../claude/src/modules/system.ts
+var SystemModule = class extends BaseModule {
+  /**
+   * Get health status
+   */
+  async health() {
+    return this.request("system.health");
+  }
+  /**
+   * Get system status
+   */
+  async status() {
+    return this.request("system.status");
+  }
+  /**
+   * Ping (simple health check)
+   */
+  async ping() {
+    try {
+      const health = await this.health();
+      return {
+        ok: health.healthy,
+        timestamp: Date.now()
+      };
+    } catch {
+      return {
+        ok: false,
+        timestamp: Date.now()
+      };
+    }
+  }
+};
+
+// ../claude/src/transport/cli.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// ../claude/src/transport/process-manager.ts
+import { spawn } from "child_process";
+var ProcessManager = class {
+  constructor(config, events) {
+    this.config = config;
+    this.events = events;
+  }
+  processes = /* @__PURE__ */ new Map();
+  cleanupInterval = null;
+  events;
+  /**
+   * Spawn a new Claude process
+   */
+  async spawn(options) {
+    if (this.processes.size >= this.config.maxProcesses) {
+      throw new ProcessError(
+        `Maximum process limit reached (${this.config.maxProcesses})`,
+        options.sessionKey
+      );
+    }
+    const args = this.buildArgs(options);
+    const stdinMode = options.message ? "ignore" : "pipe";
+    const proc = spawn(this.config.cliPath, args, {
+      cwd: options.workingDirectory || this.config.workingDirectory || process.cwd(),
+      env: process.env,
+      stdio: [stdinMode, "pipe", "pipe"]
+    });
+    const claudeProc = {
+      sessionKey: options.sessionKey,
+      process: proc,
+      status: "idle",
+      createdAt: Date.now(),
+      lastUsedAt: Date.now()
+    };
+    this.setupProcessHandlers(claudeProc);
+    this.processes.set(options.sessionKey, claudeProc);
+    this.events.emit("process:spawn", options.sessionKey, proc.pid ?? 0);
+    return claudeProc;
+  }
+  /**
+   * Build CLI arguments
+   */
+  buildArgs(options) {
+    const outputFormat = options.outputFormat || "json";
+    const args = ["--print"];
+    if (options.message) {
+      args.push(options.message);
+    }
+    args.push("--output-format", outputFormat);
+    if (outputFormat === "stream-json") {
+      args.push("--verbose");
+    }
+    const model = options.model || this.config.model;
+    if (model) {
+      args.push("--model", model);
+    }
+    if (options.thinking && options.thinking !== "none") {
+      args.push("--thinking", options.thinking);
+    }
+    const permissionMode = options.permissionMode || this.config.permissionMode;
+    if (permissionMode) {
+      args.push("--permission-mode", permissionMode);
+    }
+    const workingDir = options.workingDirectory || this.config.workingDirectory;
+    if (workingDir) {
+      args.push("--add-dir", workingDir);
+    }
+    return args;
+  }
+  /**
+   * Setup process event handlers
+   */
+  setupProcessHandlers(proc) {
+    proc.process.on("error", (error) => {
+      proc.status = "error";
+      this.events.emit("process:error", proc.sessionKey, error);
+    });
+    proc.process.on("exit", (code) => {
+      this.processes.delete(proc.sessionKey);
+      this.events.emit("process:exit", proc.sessionKey, code);
+    });
+    proc.process.stderr?.on("data", (data) => {
+      const message = data.toString();
+      this.events.emit("agent:log", proc.sessionKey, message, "error");
+    });
+  }
+  /**
+   * Get existing process by session key
+   */
+  get(sessionKey) {
+    return this.processes.get(sessionKey);
+  }
+  /**
+   * Update process last used time
+   */
+  touch(sessionKey) {
+    const proc = this.processes.get(sessionKey);
+    if (proc) {
+      proc.lastUsedAt = Date.now();
+    }
+  }
+  /**
+   * Set process status
+   */
+  setStatus(sessionKey, status) {
+    const proc = this.processes.get(sessionKey);
+    if (proc) {
+      proc.status = status;
+    }
+  }
+  /**
+   * Kill a specific process
+   */
+  kill(sessionKey) {
+    const proc = this.processes.get(sessionKey);
+    if (proc) {
+      try {
+        proc.process.kill("SIGTERM");
+      } catch (error) {
+        console.error(`Error killing process ${sessionKey}:`, error);
+      }
+      this.processes.delete(sessionKey);
+    }
+  }
+  /**
+   * Kill all processes
+   */
+  killAll() {
+    for (const sessionKey of Array.from(this.processes.keys())) {
+      this.kill(sessionKey);
+    }
+  }
+  /**
+   * Start periodic cleanup of idle processes
+   */
+  startCleanup(intervalMs = 6e4) {
+    if (this.cleanupInterval) {
+      return;
+    }
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupIdleProcesses();
+    }, intervalMs);
+  }
+  /**
+   * Stop cleanup interval
+   */
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  /**
+   * Cleanup idle processes
+   */
+  cleanupIdleProcesses() {
+    const now = Date.now();
+    const timeout = this.config.processIdleTimeout;
+    for (const [sessionKey, proc] of this.processes.entries()) {
+      if (proc.status === "idle" && now - proc.lastUsedAt > timeout) {
+        this.kill(sessionKey);
+      }
+    }
+  }
+  /**
+   * Get process count
+   */
+  getProcessCount() {
+    return this.processes.size;
+  }
+  /**
+   * Get all session keys with active processes
+   */
+  getActiveSessionKeys() {
+    return Array.from(this.processes.keys());
+  }
+};
+
+// ../claude/src/session/storage.ts
+var InMemorySessionStorage = class {
+  sessions = /* @__PURE__ */ new Map();
+  get(sessionKey) {
+    return this.sessions.get(sessionKey);
+  }
+  set(sessionKey, session) {
+    this.sessions.set(sessionKey, session);
+  }
+  delete(sessionKey) {
+    this.sessions.delete(sessionKey);
+  }
+  has(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  getAll() {
+    return Array.from(this.sessions.values());
+  }
+  clear() {
+    this.sessions.clear();
+  }
+  count() {
+    return this.sessions.size;
+  }
+};
+
+// ../claude/src/session/manager.ts
+var SessionManager = class {
+  storage;
+  events;
+  constructor(events, storage) {
+    this.storage = storage || new InMemorySessionStorage();
+    this.events = events;
+  }
+  /**
+   * Get or create a session
+   */
+  getOrCreateSession(sessionKey, agentId) {
+    let session = this.storage.get(sessionKey);
+    if (!session) {
+      session = {
+        sessionKey,
+        agentId,
+        messages: [],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      this.storage.set(sessionKey, session);
+      this.events.emit("session:created", sessionKey);
+    }
+    return session;
+  }
+  /**
+   * Get session by key
+   */
+  getSession(sessionKey) {
+    return this.storage.get(sessionKey);
+  }
+  /**
+   * Add message to session
+   */
+  addMessage(sessionKey, message) {
+    const session = this.storage.get(sessionKey);
+    if (!session) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    session.messages.push(message);
+    session.updatedAt = Date.now();
+    this.storage.set(sessionKey, session);
+  }
+  /**
+   * Get session history
+   */
+  getHistory(sessionKey, limit) {
+    const session = this.storage.get(sessionKey);
+    if (!session) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    if (limit && limit > 0) {
+      return session.messages.slice(-limit);
+    }
+    return session.messages;
+  }
+  /**
+   * List sessions with optional filtering
+   */
+  listSessions(options) {
+    let sessions = this.storage.getAll();
+    if (options?.agentId) {
+      sessions = sessions.filter((s) => s.agentId === options.agentId);
+    }
+    if (options?.activeWithinMinutes) {
+      const cutoff = Date.now() - options.activeWithinMinutes * 60 * 1e3;
+      sessions = sessions.filter((s) => s.updatedAt >= cutoff);
+    }
+    sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    if (options?.offset) {
+      sessions = sessions.slice(options.offset);
+    }
+    if (options?.limit) {
+      sessions = sessions.slice(0, options.limit);
+    }
+    return sessions;
+  }
+  /**
+   * Delete session
+   */
+  deleteSession(sessionKey) {
+    if (!this.storage.has(sessionKey)) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    this.storage.delete(sessionKey);
+    this.events.emit("session:deleted", sessionKey);
+  }
+  /**
+   * Update session process ID
+   */
+  setProcessId(sessionKey, processId) {
+    const session = this.storage.get(sessionKey);
+    if (!session) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    session.processId = processId;
+    session.updatedAt = Date.now();
+    this.storage.set(sessionKey, session);
+  }
+  /**
+   * Clear process ID from session
+   */
+  clearProcessId(sessionKey) {
+    const session = this.storage.get(sessionKey);
+    if (session) {
+      delete session.processId;
+      session.updatedAt = Date.now();
+      this.storage.set(sessionKey, session);
+    }
+  }
+  /**
+   * Get session count
+   */
+  getSessionCount() {
+    return this.storage.count();
+  }
+  /**
+   * Clear all sessions
+   */
+  clearAll() {
+    this.storage.clear();
+  }
+};
+
+// ../claude/src/transport/cli.ts
+var execAsync = promisify(exec);
+var CLITransport = class {
+  state = "disconnected";
+  processManager;
+  sessionManager;
+  events;
+  config;
+  constructor(config, events) {
+    this.events = events;
+    this.config = {
+      ...config,
+      autoConnect: config.autoConnect ?? true,
+      timeout: config.timeout ?? 3e5
+      // 5 minutes default
+    };
+    this.processManager = new ProcessManager(
+      {
+        cliPath: config.cliPath,
+        maxProcesses: config.maxProcesses,
+        processIdleTimeout: config.processIdleTimeout,
+        model: config.model,
+        permissionMode: config.permissionMode,
+        workingDirectory: config.workingDirectory
+      },
+      events
+    );
+    this.sessionManager = new SessionManager(events);
+  }
+  /**
+   * Connect - verify Claude CLI is available
+   */
+  async connect() {
+    if (this.state === "connected") {
+      return;
+    }
+    this.state = "connecting";
+    this.events.emit("connection:state", "connecting");
+    try {
+      await this.verifyCLI();
+      this.processManager.startCleanup();
+      this.state = "connected";
+      this.events.emit("connection:state", "connected");
+      this.events.emit("connection:connected");
+    } catch (error) {
+      this.state = "error";
+      this.events.emit("connection:state", "error");
+      this.events.emit("connection:error", error);
+      throw new ConnectionError("Failed to connect to Claude CLI", void 0, error);
+    }
+  }
+  /**
+   * Verify Claude CLI is available
+   */
+  async verifyCLI() {
+    try {
+      const { stdout } = await execAsync(`${this.config.cliPath} --version`);
+      console.log(`Claude CLI available: ${stdout.trim()}`);
+    } catch (error) {
+      throw new CLIError(
+        `Claude CLI not found at '${this.config.cliPath}'. Ensure Claude CLI is installed and in PATH.`,
+        error.code,
+        "",
+        error.message
+      );
+    }
+  }
+  /**
+   * Disconnect and cleanup
+   */
+  disconnect() {
+    if (this.state === "disconnected") {
+      return;
+    }
+    this.processManager.killAll();
+    this.processManager.stopCleanup();
+    this.state = "disconnected";
+    this.events.emit("connection:state", "disconnected");
+    this.events.emit("connection:disconnected");
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected";
+  }
+  /**
+   * Get connection state
+   */
+  getConnectionState() {
+    return this.state;
+  }
+  /**
+   * Make an RPC request
+   */
+  async request(method, params = {}) {
+    if (!this.isConnected()) {
+      throw new ConnectionError("Not connected to Claude CLI");
+    }
+    switch (method) {
+      case "chat.send":
+        return this.handleChatSend(params);
+      case "sessions.list":
+        return this.handleSessionsList(params);
+      case "sessions.get":
+        return this.handleSessionsGet(params.sessionKey);
+      case "sessions.delete":
+        return this.handleSessionsDelete(params.sessionKey);
+      case "sessions.history":
+        return this.handleSessionsHistory(params.sessionKey);
+      case "system.health":
+        return this.handleSystemHealth();
+      case "system.status":
+        return this.handleSystemStatus();
+      case "agents.list":
+        return this.handleAgentsList();
+      case "agents.get":
+        return this.handleAgentsGet(params.agentId);
+      default:
+        throw new Error(`Unknown RPC method: ${method}`);
+    }
+  }
+  /**
+   * Handle chat.send request
+   * Uses --output-format=json for single-shot responses
+   */
+  async handleChatSend(options) {
+    const sessionKey = options.sessionKey || `claude-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    const agentId = options.agentId || "claude";
+    const timeout = options.timeout || this.config.timeout;
+    const session = this.sessionManager.getOrCreateSession(sessionKey, agentId);
+    this.sessionManager.addMessage(sessionKey, {
+      role: "user",
+      content: options.message,
+      timestamp: Date.now()
+    });
+    const existingProc = this.processManager.get(sessionKey);
+    if (existingProc) {
+      this.processManager.kill(sessionKey);
+    }
+    const proc = await this.processManager.spawn({
+      sessionKey,
+      model: this.config.model,
+      thinking: options.thinking,
+      permissionMode: this.config.permissionMode,
+      workingDirectory: this.config.workingDirectory,
+      timeout,
+      message: options.message,
+      outputFormat: "json"
+    });
+    this.processManager.setStatus(sessionKey, "busy");
+    try {
+      const output = await Promise.race([
+        this.collectStdout(proc.process),
+        this.createTimeoutPromise(timeout)
+      ]);
+      let content = "";
+      let thinking;
+      try {
+        const parsed = JSON.parse(output);
+        content = parsed.result || "";
+        if (parsed.thinking) {
+          thinking = parsed.thinking;
+        }
+      } catch {
+        content = output.trim();
+      }
+      this.sessionManager.addMessage(sessionKey, {
+        role: "assistant",
+        content,
+        thinking,
+        timestamp: Date.now()
+      });
+      this.processManager.setStatus(sessionKey, "idle");
+      this.processManager.touch(sessionKey);
+      return {
+        sessionKey,
+        agentId,
+        response: content,
+        thinking,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      this.processManager.setStatus(sessionKey, "error");
+      throw error;
+    }
+  }
+  /**
+   * Collect full stdout from a child process as a string.
+   * Also captures stderr — if the process exits with no stdout, throws with stderr.
+   */
+  collectStdout(proc) {
+    return new Promise((resolve, reject) => {
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      proc.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+      proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+      proc.stdout?.on("error", reject);
+      proc.on("error", reject);
+      proc.on("close", (code) => {
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        if (stdout) {
+          resolve(stdout);
+        } else if (code !== 0 || stderr) {
+          reject(new Error(`Claude CLI exited with code ${code}${stderr ? `: ${stderr}` : ""}`));
+        } else {
+          resolve("");
+        }
+      });
+    });
+  }
+  /**
+   * Handle sessions.list request
+   */
+  async handleSessionsList(options) {
+    const sessions = this.sessionManager.listSessions(options);
+    return {
+      sessions: sessions.map((s) => ({
+        sessionKey: s.sessionKey,
+        agentId: s.agentId,
+        messageCount: s.messages.length,
+        createdAt: s.createdAt,
+        updatedAt: s.updatedAt
+      })),
+      total: sessions.length
+    };
+  }
+  /**
+   * Handle sessions.get request
+   */
+  async handleSessionsGet(sessionKey) {
+    const session = this.sessionManager.getSession(sessionKey);
+    if (!session) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    return {
+      sessionKey: session.sessionKey,
+      agentId: session.agentId,
+      messageCount: session.messages.length,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt
+    };
+  }
+  /**
+   * Handle sessions.delete request
+   */
+  async handleSessionsDelete(sessionKey) {
+    this.processManager.kill(sessionKey);
+    this.sessionManager.deleteSession(sessionKey);
+  }
+  /**
+   * Handle sessions.history request
+   */
+  async handleSessionsHistory(sessionKey) {
+    const messages = this.sessionManager.getHistory(sessionKey);
+    return { messages };
+  }
+  /**
+   * Handle system.health request
+   */
+  async handleSystemHealth() {
+    try {
+      await this.verifyCLI();
+      return {
+        healthy: true,
+        cliAvailable: true,
+        activeSessions: this.sessionManager.getSessionCount(),
+        activeProcesses: this.processManager.getProcessCount()
+      };
+    } catch {
+      return {
+        healthy: false,
+        cliAvailable: false,
+        activeSessions: this.sessionManager.getSessionCount(),
+        activeProcesses: this.processManager.getProcessCount()
+      };
+    }
+  }
+  /**
+   * Handle system.status request
+   */
+  async handleSystemStatus() {
+    return {
+      state: this.state,
+      activeSessions: this.sessionManager.getSessionCount(),
+      activeProcesses: this.processManager.getProcessCount(),
+      cliPath: this.config.cliPath
+    };
+  }
+  /**
+   * Handle agents.list request (stub)
+   */
+  async handleAgentsList() {
+    return {
+      agents: [
+        {
+          agentId: "claude",
+          status: "available",
+          workspace: this.config.workingDirectory
+        }
+      ],
+      defaultAgentId: "claude"
+    };
+  }
+  /**
+   * Handle agents.get request (stub)
+   */
+  async handleAgentsGet(agentId) {
+    return {
+      agentId,
+      status: "available",
+      workspace: this.config.workingDirectory
+    };
+  }
+  /**
+   * Create timeout promise
+   */
+  createTimeoutPromise(timeout) {
+    return new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new TimeoutError("Operation timed out", timeout));
+      }, timeout);
+    });
+  }
+  /**
+   * Subscribe to event
+   */
+  on(event, handler) {
+    this.events.on(event, handler);
+  }
+  /**
+   * Unsubscribe from event
+   */
+  off(event, handler) {
+    this.events.off(event, handler);
+  }
+  /**
+   * Emit event
+   */
+  emit(event, ...args) {
+    this.events.emit(event, ...args);
+  }
+  /**
+   * Get process manager (for internal use)
+   */
+  getProcessManager() {
+    return this.processManager;
+  }
+  /**
+   * Get session manager (for internal use)
+   */
+  getSessionManager() {
+    return this.sessionManager;
+  }
+};
+
+// ../claude/src/sdk.ts
+var DEFAULT_CONFIG = {
+  cliPath: "claude",
+  timeout: 3e5,
+  // 5 minutes
+  maxProcesses: 10,
+  processIdleTimeout: 6e5,
+  // 10 minutes
+  model: "claude-sonnet-4-5",
+  permissionMode: "default",
+  workingDirectory: process.cwd(),
+  autoConnect: true
+};
+var ClaudeSDK = class _ClaudeSDK {
+  transport;
+  events;
+  // Domain modules
+  system;
+  agents;
+  sessions;
+  chat;
+  constructor(config) {
+    this.events = createEventEmitter();
+    const transportConfig = {
+      cliPath: config.cliPath,
+      timeout: config.timeout,
+      maxProcesses: config.maxProcesses,
+      processIdleTimeout: config.processIdleTimeout,
+      model: config.model,
+      permissionMode: config.permissionMode,
+      workingDirectory: config.workingDirectory,
+      autoConnect: false
+      // We'll connect manually after initialization
+    };
+    this.transport = new CLITransport(transportConfig, this.events);
+    this.system = new SystemModule(this.transport, this.events);
+    this.agents = new AgentsModule(this.transport, this.events);
+    this.sessions = new SessionsModule(this.transport, this.events);
+    this.chat = new ChatModule(this.transport, this.events);
+  }
+  /**
+   * Create a new ClaudeSDK instance
+   * Auto-connects by default
+   */
+  static async create(config) {
+    const fullConfig = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    const sdk = new _ClaudeSDK(fullConfig);
+    if (fullConfig.autoConnect) {
+      await sdk.connect();
+    }
+    return sdk;
+  }
+  /**
+   * Create a disconnected SDK instance
+   * Must call connect() manually
+   */
+  static createDisconnected(config) {
+    const fullConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      autoConnect: false
+    };
+    return new _ClaudeSDK(fullConfig);
+  }
+  /**
+   * Connect to Claude CLI
+   */
+  async connect() {
+    await this.transport.connect();
+  }
+  /**
+   * Disconnect and cleanup
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.transport.isConnected();
+  }
+  /**
+   * Get connection state
+   */
+  getConnectionState() {
+    return this.transport.getConnectionState();
+  }
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    this.events.on(event, handler);
+    return this;
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    this.events.once(event, handler);
+    return this;
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    this.events.off(event, handler);
+    return this;
+  }
+  /**
+   * Remove all listeners for an event
+   */
+  removeAllListeners(event) {
+    this.events.removeAllListeners(event);
+    return this;
+  }
+  /**
+   * Wait for an event (promisified)
+   */
+  waitFor(event, timeout) {
+    return this.events.waitFor(event, timeout);
+  }
+};
+export {
+  CLIError,
+  ClaudeError,
+  ClaudeSDK,
+  ConnectionError,
+  NotConnectedError,
+  NotFoundError,
+  NotImplementedError,
+  ProcessError,
+  StreamParseError,
+  TimeoutError,
+  ValidationError
+};