@openacp/cli 0.2.5 → 0.2.12

package/dist/chunk-6YLIH7L5.js

@@ -1,669 +0,0 @@
-import {
-  log
-} from "./chunk-M5ZYTPZY.js";
-
-// packages/core/src/streams.ts
-function nodeToWebWritable(nodeStream) {
-  return new WritableStream({
-    write(chunk) {
-      return new Promise((resolve, reject) => {
-        nodeStream.write(Buffer.from(chunk), (err) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      });
-    }
-  });
-}
-function nodeToWebReadable(nodeStream) {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => {
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      nodeStream.on("end", () => controller.close());
-      nodeStream.on("error", (err) => controller.error(err));
-    }
-  });
-}
-
-// packages/core/src/stderr-capture.ts
-var StderrCapture = class {
-  constructor(maxLines = 50) {
-    this.maxLines = maxLines;
-  }
-  lines = [];
-  append(chunk) {
-    this.lines.push(...chunk.split("\n").filter(Boolean));
-    if (this.lines.length > this.maxLines) {
-      this.lines = this.lines.slice(-this.maxLines);
-    }
-  }
-  getLastLines() {
-    return this.lines.join("\n");
-  }
-};
-
-// packages/core/src/agent-instance.ts
-import { spawn, execSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { randomUUID } from "crypto";
-import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
-function resolveAgentCommand(cmd) {
-  const packageDirs = [
-    path.resolve(process.cwd(), "node_modules", "@zed-industries", cmd, "dist", "index.js"),
-    path.resolve(process.cwd(), "node_modules", cmd, "dist", "index.js")
-  ];
-  for (const jsPath of packageDirs) {
-    if (fs.existsSync(jsPath)) {
-      return { command: process.execPath, args: [jsPath] };
-    }
-  }
-  const localBin = path.resolve(process.cwd(), "node_modules", ".bin", cmd);
-  if (fs.existsSync(localBin)) {
-    const content = fs.readFileSync(localBin, "utf-8");
-    if (content.startsWith("#!/usr/bin/env node")) {
-      return { command: process.execPath, args: [localBin] };
-    }
-    const match = content.match(/"([^"]+\.js)"/);
-    if (match) {
-      const target = path.resolve(path.dirname(localBin), match[1]);
-      if (fs.existsSync(target)) {
-        return { command: process.execPath, args: [target] };
-      }
-    }
-  }
-  try {
-    const fullPath = execSync(`which ${cmd}`, { encoding: "utf-8" }).trim();
-    if (fullPath) {
-      const content = fs.readFileSync(fullPath, "utf-8");
-      if (content.startsWith("#!/usr/bin/env node")) {
-        return { command: process.execPath, args: [fullPath] };
-      }
-    }
-  } catch {
-  }
-  return { command: cmd, args: [] };
-}
-var AgentInstance = class _AgentInstance {
-  connection;
-  child;
-  stderrCapture;
-  terminals = /* @__PURE__ */ new Map();
-  sessionId;
-  agentName;
-  // Callbacks — set by core when wiring events
-  onSessionUpdate = () => {
-  };
-  onPermissionRequest = async () => "";
-  constructor(agentName) {
-    this.agentName = agentName;
-  }
-  static async spawn(agentDef, workingDirectory) {
-    const instance = new _AgentInstance(agentDef.name);
-    const resolved = resolveAgentCommand(agentDef.command);
-    log.debug(`Spawning agent "${agentDef.name}" \u2192 ${resolved.command} ${resolved.args.join(" ")}`);
-    instance.child = spawn(resolved.command, [...resolved.args, ...agentDef.args], {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd: workingDirectory,
-      env: { ...process.env, ...agentDef.env }
-    });
-    await new Promise((resolve, reject) => {
-      instance.child.on("error", (err) => {
-        reject(new Error(`Failed to spawn agent "${agentDef.name}": ${err.message}. Is "${agentDef.command}" installed?`));
-      });
-      instance.child.on("spawn", () => resolve());
-    });
-    instance.stderrCapture = new StderrCapture(50);
-    instance.child.stderr.on("data", (chunk) => {
-      instance.stderrCapture.append(chunk.toString());
-    });
-    const toAgent = nodeToWebWritable(instance.child.stdin);
-    const fromAgent = nodeToWebReadable(instance.child.stdout);
-    const stream = ndJsonStream(toAgent, fromAgent);
-    instance.connection = new ClientSideConnection(
-      (_agent) => instance.createClient(_agent),
-      stream
-    );
-    await instance.connection.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true },
-        terminal: true
-      }
-    });
-    const response = await instance.connection.newSession({
-      cwd: workingDirectory,
-      mcpServers: []
-    });
-    instance.sessionId = response.sessionId;
-    instance.child.on("exit", (code, signal) => {
-      if (code !== 0 && code !== null) {
-        const stderr = instance.stderrCapture.getLastLines();
-        instance.onSessionUpdate({
-          type: "error",
-          message: `Agent crashed (exit code ${code})
-${stderr}`
-        });
-      }
-    });
-    instance.connection.closed.then(() => {
-      log.debug("ACP connection closed for", instance.agentName);
-    });
-    log.info(`Agent "${agentDef.name}" spawned with session ${response.sessionId}`);
-    return instance;
-  }
-  // createClient — implemented in Task 6b
-  createClient(_agent) {
-    const self = this;
-    const MAX_OUTPUT_BYTES = 1024 * 1024;
-    return {
-      // ── Session updates ──────────────────────────────────────────────────
-      async sessionUpdate(params) {
-        const update = params.update;
-        let event = null;
-        switch (update.sessionUpdate) {
-          case "agent_message_chunk":
-            if (update.content.type === "text") {
-              event = { type: "text", content: update.content.text };
-            }
-            break;
-          case "agent_thought_chunk":
-            if (update.content.type === "text") {
-              event = { type: "thought", content: update.content.text };
-            }
-            break;
-          case "tool_call":
-            event = {
-              type: "tool_call",
-              id: update.toolCallId,
-              name: update.title,
-              kind: update.kind ?? void 0,
-              status: update.status ?? "pending",
-              content: update.content ?? void 0
-            };
-            break;
-          case "tool_call_update":
-            event = {
-              type: "tool_update",
-              id: update.toolCallId,
-              status: update.status ?? "pending",
-              content: update.content ?? void 0
-            };
-            break;
-          case "plan":
-            event = { type: "plan", entries: update.entries };
-            break;
-          case "usage_update":
-            event = {
-              type: "usage",
-              tokensUsed: update.used,
-              contextSize: update.size,
-              cost: update.cost ?? void 0
-            };
-            break;
-          case "available_commands_update":
-            event = { type: "commands_update", commands: update.availableCommands };
-            break;
-          default:
-            return;
-        }
-        if (event !== null) {
-          self.onSessionUpdate(event);
-        }
-      },
-      // ── Permission requests ──────────────────────────────────────────────
-      async requestPermission(params) {
-        const permissionRequest = {
-          id: params.toolCall.toolCallId,
-          description: params.toolCall.title ?? params.toolCall.toolCallId,
-          options: params.options.map((opt) => ({
-            id: opt.optionId,
-            label: opt.name,
-            isAllow: opt.kind === "allow_once" || opt.kind === "allow_always"
-          }))
-        };
-        const selectedOptionId = await self.onPermissionRequest(permissionRequest);
-        return {
-          outcome: { outcome: "selected", optionId: selectedOptionId }
-        };
-      },
-      // ── File operations ──────────────────────────────────────────────────
-      async readTextFile(params) {
-        const content = await fs.promises.readFile(params.path, "utf-8");
-        return { content };
-      },
-      async writeTextFile(params) {
-        await fs.promises.mkdir(path.dirname(params.path), { recursive: true });
-        await fs.promises.writeFile(params.path, params.content, "utf-8");
-        return {};
-      },
-      // ── Terminal operations ──────────────────────────────────────────────
-      async createTerminal(params) {
-        const terminalId = randomUUID();
-        const args = params.args ?? [];
-        const env = {};
-        for (const ev of params.env ?? []) {
-          env[ev.name] = ev.value;
-        }
-        const childProcess = spawn(params.command, args, {
-          cwd: params.cwd ?? void 0,
-          env: { ...process.env, ...env },
-          shell: false
-        });
-        const state = {
-          process: childProcess,
-          output: "",
-          exitStatus: null
-        };
-        self.terminals.set(terminalId, state);
-        const outputByteLimit = params.outputByteLimit ?? MAX_OUTPUT_BYTES;
-        const appendOutput = (chunk) => {
-          state.output += chunk;
-          const bytes = Buffer.byteLength(state.output, "utf-8");
-          if (bytes > outputByteLimit) {
-            const excess = bytes - outputByteLimit;
-            state.output = state.output.slice(excess);
-          }
-        };
-        childProcess.stdout?.on("data", (chunk) => appendOutput(chunk.toString()));
-        childProcess.stderr?.on("data", (chunk) => appendOutput(chunk.toString()));
-        childProcess.on("exit", (code, signal) => {
-          state.exitStatus = { exitCode: code, signal };
-        });
-        return { terminalId };
-      },
-      async terminalOutput(params) {
-        const state = self.terminals.get(params.terminalId);
-        if (!state) {
-          throw new Error(`Terminal not found: ${params.terminalId}`);
-        }
-        return {
-          output: state.output,
-          truncated: false,
-          exitStatus: state.exitStatus ? { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal } : void 0
-        };
-      },
-      async waitForTerminalExit(params) {
-        const state = self.terminals.get(params.terminalId);
-        if (!state) {
-          throw new Error(`Terminal not found: ${params.terminalId}`);
-        }
-        if (state.exitStatus !== null) {
-          return { exitCode: state.exitStatus.exitCode, signal: state.exitStatus.signal };
-        }
-        return new Promise((resolve) => {
-          state.process.on("exit", (code, signal) => {
-            resolve({ exitCode: code, signal });
-          });
-        });
-      },
-      async killTerminal(params) {
-        const state = self.terminals.get(params.terminalId);
-        if (!state) {
-          throw new Error(`Terminal not found: ${params.terminalId}`);
-        }
-        state.process.kill("SIGTERM");
-        return {};
-      },
-      async releaseTerminal(params) {
-        const state = self.terminals.get(params.terminalId);
-        if (!state) {
-          return;
-        }
-        state.process.kill("SIGKILL");
-        self.terminals.delete(params.terminalId);
-      }
-    };
-  }
-  async prompt(text) {
-    return this.connection.prompt({
-      sessionId: this.sessionId,
-      prompt: [{ type: "text", text }]
-    });
-  }
-  async cancel() {
-    await this.connection.cancel({ sessionId: this.sessionId });
-  }
-  async destroy() {
-    for (const [, t] of this.terminals) {
-      t.process.kill("SIGKILL");
-    }
-    this.terminals.clear();
-    this.child.kill("SIGTERM");
-    setTimeout(() => {
-      if (!this.child.killed) this.child.kill("SIGKILL");
-    }, 1e4);
-  }
-};
-
-// packages/core/src/agent-manager.ts
-var AgentManager = class {
-  constructor(config) {
-    this.config = config;
-  }
-  getAvailableAgents() {
-    return Object.entries(this.config.agents).map(([name, cfg]) => ({
-      name,
-      command: cfg.command,
-      args: cfg.args,
-      workingDirectory: cfg.workingDirectory,
-      env: cfg.env
-    }));
-  }
-  getAgent(name) {
-    const cfg = this.config.agents[name];
-    if (!cfg) return void 0;
-    return { name, ...cfg };
-  }
-  async spawn(agentName, workingDirectory) {
-    const agentDef = this.getAgent(agentName);
-    if (!agentDef) throw new Error(`Agent "${agentName}" not found in config`);
-    return AgentInstance.spawn(agentDef, workingDirectory);
-  }
-};
-
-// packages/core/src/session.ts
-import { nanoid } from "nanoid";
-var Session = class {
-  id;
-  channelId;
-  threadId = "";
-  agentName;
-  workingDirectory;
-  agentInstance;
-  status = "initializing";
-  name;
-  promptQueue = [];
-  promptRunning = false;
-  createdAt = /* @__PURE__ */ new Date();
-  adapter;
-  // Set by wireSessionEvents for renaming
-  pendingPermission;
-  constructor(opts) {
-    this.id = opts.id || nanoid(12);
-    this.channelId = opts.channelId;
-    this.agentName = opts.agentName;
-    this.workingDirectory = opts.workingDirectory;
-    this.agentInstance = opts.agentInstance;
-  }
-  async enqueuePrompt(text) {
-    if (this.promptRunning) {
-      this.promptQueue.push(text);
-      log.debug(`Prompt queued for session ${this.id} (${this.promptQueue.length} in queue)`);
-      return;
-    }
-    await this.runPrompt(text);
-  }
-  async runPrompt(text) {
-    this.promptRunning = true;
-    this.status = "active";
-    try {
-      await this.agentInstance.prompt(text);
-      if (!this.name) {
-        await this.autoName();
-      }
-    } catch (err) {
-      this.status = "error";
-      log.error(`Prompt failed for session ${this.id}:`, err);
-    } finally {
-      this.promptRunning = false;
-      if (this.promptQueue.length > 0) {
-        const next = this.promptQueue.shift();
-        await this.runPrompt(next);
-      }
-    }
-  }
-  // NOTE: This injects a summary prompt into the agent's conversation history.
-  // Known Phase 1 limitation — the agent sees this prompt in its context.
-  async autoName() {
-    let title = "";
-    const prevHandler = this.agentInstance.onSessionUpdate;
-    this.agentInstance.onSessionUpdate = (event) => {
-      if (event.type === "text") title += event.content;
-    };
-    try {
-      await this.agentInstance.prompt(
-        "Summarize this conversation in max 5 words for a topic title. Reply ONLY with the title, nothing else."
-      );
-      this.name = title.trim().slice(0, 50);
-      if (this.adapter && this.name) {
-        await this.adapter.renameSessionThread(this.id, this.name);
-      }
-    } catch {
-      this.name = `Session ${this.id.slice(0, 6)}`;
-    } finally {
-      this.agentInstance.onSessionUpdate = prevHandler;
-    }
-  }
-  async cancel() {
-    this.status = "cancelled";
-    await this.agentInstance.cancel();
-  }
-  async destroy() {
-    await this.agentInstance.destroy();
-  }
-};
-
-// packages/core/src/session-manager.ts
-var SessionManager = class {
-  sessions = /* @__PURE__ */ new Map();
-  async createSession(channelId, agentName, workingDirectory, agentManager) {
-    const agentInstance = await agentManager.spawn(agentName, workingDirectory);
-    const session = new Session({ channelId, agentName, workingDirectory, agentInstance });
-    this.sessions.set(session.id, session);
-    return session;
-  }
-  getSession(sessionId) {
-    return this.sessions.get(sessionId);
-  }
-  getSessionByThread(channelId, threadId) {
-    for (const session of this.sessions.values()) {
-      if (session.channelId === channelId && session.threadId === threadId) {
-        return session;
-      }
-    }
-    return void 0;
-  }
-  async cancelSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) await session.cancel();
-  }
-  listSessions(channelId) {
-    const all = Array.from(this.sessions.values());
-    if (channelId) return all.filter((s) => s.channelId === channelId);
-    return all;
-  }
-  async destroyAll() {
-    for (const session of this.sessions.values()) {
-      await session.destroy();
-    }
-    this.sessions.clear();
-  }
-};
-
-// packages/core/src/notification.ts
-var NotificationManager = class {
-  constructor(adapters) {
-    this.adapters = adapters;
-  }
-  async notify(channelId, notification) {
-    const adapter = this.adapters.get(channelId);
-    if (adapter) {
-      await adapter.sendNotification(notification);
-    }
-  }
-  async notifyAll(notification) {
-    for (const adapter of this.adapters.values()) {
-      await adapter.sendNotification(notification);
-    }
-  }
-};
-
-// packages/core/src/core.ts
-var OpenACPCore = class {
-  configManager;
-  agentManager;
-  sessionManager;
-  notificationManager;
-  adapters = /* @__PURE__ */ new Map();
-  constructor(configManager) {
-    this.configManager = configManager;
-    const config = configManager.get();
-    this.agentManager = new AgentManager(config);
-    this.sessionManager = new SessionManager();
-    this.notificationManager = new NotificationManager(this.adapters);
-  }
-  registerAdapter(name, adapter) {
-    this.adapters.set(name, adapter);
-  }
-  async start() {
-    for (const adapter of this.adapters.values()) {
-      await adapter.start();
-    }
-  }
-  async stop() {
-    try {
-      await this.notificationManager.notifyAll({
-        sessionId: "system",
-        type: "error",
-        summary: "OpenACP is shutting down"
-      });
-    } catch {
-    }
-    await this.sessionManager.destroyAll();
-    for (const adapter of this.adapters.values()) {
-      await adapter.stop();
-    }
-  }
-  // --- Message Routing ---
-  async handleMessage(message) {
-    const config = this.configManager.get();
-    if (config.security.allowedUserIds.length > 0) {
-      if (!config.security.allowedUserIds.includes(message.userId)) return;
-    }
-    const activeSessions = this.sessionManager.listSessions().filter((s) => s.status === "active" || s.status === "initializing");
-    if (activeSessions.length >= config.security.maxConcurrentSessions) {
-      const adapter = this.adapters.get(message.channelId);
-      if (adapter) {
-        await adapter.sendMessage("system", {
-          type: "error",
-          text: `Max concurrent sessions (${config.security.maxConcurrentSessions}) reached. Cancel a session first.`
-        });
-      }
-      return;
-    }
-    const session = this.sessionManager.getSessionByThread(message.channelId, message.threadId);
-    if (!session) return;
-    await session.enqueuePrompt(message.text);
-  }
-  async handleNewSession(channelId, agentName, workspacePath) {
-    const config = this.configManager.get();
-    const resolvedAgent = agentName || config.defaultAgent;
-    const resolvedWorkspace = this.configManager.resolveWorkspace(
-      workspacePath || config.agents[resolvedAgent]?.workingDirectory
-    );
-    const session = await this.sessionManager.createSession(
-      channelId,
-      resolvedAgent,
-      resolvedWorkspace,
-      this.agentManager
-    );
-    const adapter = this.adapters.get(channelId);
-    if (adapter) {
-      this.wireSessionEvents(session, adapter);
-    }
-    return session;
-  }
-  async handleNewChat(channelId, currentThreadId) {
-    const currentSession = this.sessionManager.getSessionByThread(channelId, currentThreadId);
-    if (!currentSession) return null;
-    return this.handleNewSession(
-      channelId,
-      currentSession.agentName,
-      currentSession.workingDirectory
-    );
-  }
-  // --- Event Wiring ---
-  toOutgoingMessage(event) {
-    switch (event.type) {
-      case "text":
-        return { type: "text", text: event.content };
-      case "thought":
-        return { type: "thought", text: event.content };
-      case "tool_call":
-        return { type: "tool_call", text: event.name, metadata: { id: event.id, kind: event.kind, status: event.status, content: event.content, locations: event.locations } };
-      case "tool_update":
-        return { type: "tool_update", text: "", metadata: { id: event.id, status: event.status, content: event.content } };
-      case "plan":
-        return { type: "plan", text: "", metadata: { entries: event.entries } };
-      case "usage":
-        return { type: "usage", text: "", metadata: { tokensUsed: event.tokensUsed, contextSize: event.contextSize, cost: event.cost } };
-      case "commands_update":
-        log.debug("Commands update:", event.commands);
-        return { type: "text", text: "" };
-      // no-op for now
-      default:
-        return { type: "text", text: "" };
-    }
-  }
-  // Public — adapters call this for assistant session wiring
-  wireSessionEvents(session, adapter) {
-    session.adapter = adapter;
-    session.agentInstance.onSessionUpdate = (event) => {
-      switch (event.type) {
-        case "text":
-        case "thought":
-        case "tool_call":
-        case "tool_update":
-        case "plan":
-        case "usage":
-          adapter.sendMessage(session.id, this.toOutgoingMessage(event));
-          break;
-        case "session_end":
-          session.status = "finished";
-          adapter.sendMessage(session.id, { type: "session_end", text: `Done (${event.reason})` });
-          this.notificationManager.notify(session.channelId, {
-            sessionId: session.id,
-            sessionName: session.name,
-            type: "completed",
-            summary: `Session "${session.name || session.id}" completed`
-          });
-          break;
-        case "error":
-          adapter.sendMessage(session.id, { type: "error", text: event.message });
-          this.notificationManager.notify(session.channelId, {
-            sessionId: session.id,
-            sessionName: session.name,
-            type: "error",
-            summary: event.message
-          });
-          break;
-        case "commands_update":
-          log.debug("Commands available:", event.commands);
-          break;
-      }
-    };
-    session.agentInstance.onPermissionRequest = async (request) => {
-      const promise = new Promise((resolve) => {
-        session.pendingPermission = { requestId: request.id, resolve };
-      });
-      await adapter.sendPermissionRequest(session.id, request);
-      return promise;
-    };
-  }
-};
-
-export {
-  nodeToWebWritable,
-  nodeToWebReadable,
-  StderrCapture,
-  AgentInstance,
-  AgentManager,
-  Session,
-  SessionManager,
-  NotificationManager,
-  OpenACPCore
-};
-//# sourceMappingURL=chunk-6YLIH7L5.js.map