@anhlp/alp 0.0.1-beta.4 → 0.0.1-beta.6

package/packages/cli/dist/acp/agent.d.ts

@@ -1,37 +0,0 @@
-import * as acp from '@agentclientprotocol/sdk';
-import type { DaemonConnection } from '@anhlp/alp-protocol/connection';
-import type { HostMcpServer, TimelineItem } from '@anhlp/alp-protocol';
-/**
- * ALP as an ACP agent (ALPD §60): an editor such as Zed starts `alp acp` and speaks
- * the Agent Client Protocol on stdio. Each ACP session is a root in alpd; this process
- * only translates, as the Paseo plugin does. A session opens in alpd on its first
- * prompt, so the user can choose its team first; its tree keeps working in alpd after
- * the editor goes away, and session/load picks it up again.
- */
-export type AcpAgentOptions = {
-    /** Opens a connection to alpd, starting it when needed. */
-    connect(): Promise<DaemonConnection>;
-    version: string;
-    /** Where diagnostics go; stdout belongs to the protocol. */
-    log?: (message: string, fields?: {
-        code?: string;
-        error?: unknown;
-    }) => void;
-};
-/** ACP's MCP servers, as ALP hosts them beside the agents' own. */
-export declare function hostServers(servers?: acp.McpServer[]): Record<string, HostMcpServer>;
-/** A prompt's content as the text ALP gives the agent: files the editor attaches are named or inlined. */
-export declare function promptText(blocks: acp.ContentBlock[]): string;
-type ToolItem = Extract<TimelineItem, {
-    kind: 'tool_call';
-}>;
-/** What kind of work a tool call is: from its typed detail, else its name or its command's first word (older Claude items are `Read {…}` commands). */
-export declare function toolKind(item: ToolItem): acp.ToolKind;
-export declare function toolTitle(item: ToolItem, cwd?: string): string;
-export declare function toolOutput(item: ToolItem): acp.ToolCallContent[];
-/** The call's input as the editor shows it raw: a command, a typed call's own fields without its long texts, or the tool's input. */
-export declare function toolInput(item: ToolItem): unknown;
-/** The file a typed call read or changed, for the editor to follow. */
-export declare function toolLocations(item: ToolItem): acp.ToolCallLocation[] | undefined;
-export declare function createAcpAgent(options: AcpAgentOptions): acp.AgentApp;
-export {};

package/packages/cli/dist/acp/agent.js

@@ -1,489 +0,0 @@
-// packages/cli/src/acp/agent.ts
-import * as acp from "@agentclientprotocol/sdk";
-import { randomUUID } from "node:crypto";
-import path from "node:path";
-var unlistedOf = ({ teams, team, teamLabel }) => teams.some((entry) => entry.id === team) ? void 0 : { id: team, label: teamLabel ?? (team === "custom" ? "Custom" : team) };
-var MODES = [
-  { id: "read-only", name: "Read only", description: "Agents read and search; nothing is changed" },
-  { id: "workspace-write", name: "Workspace write", description: "Agents change files and run commands inside the project" },
-  { id: "full-access", name: "Full access", description: "Agents may do anything, without a sandbox" }
-];
-var OUTPUT_CHARS = 2e4;
-var COMMANDS = [
-  { name: "answer", description: "Answer the question an agent asked you", input: { hint: "your answer" } },
-  { name: "dismiss", description: "Dismiss the question an agent asked you", input: { hint: "why (optional)" } }
-];
-function hostServers(servers = []) {
-  const host = {};
-  for (const server of servers) {
-    if ("command" in server) host[server.name] = { type: "stdio", command: server.command, args: server.args, env: Object.fromEntries(server.env.map((variable) => [variable.name, variable.value])) };
-    else if (server.type === "http" || server.type === "sse") host[server.name] = { type: server.type, url: server.url, headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])) };
-  }
-  return host;
-}
-function promptText(blocks) {
-  let text = "";
-  for (const block of blocks) {
-    if (block.type === "text") {
-      text += block.text;
-      continue;
-    }
-    let part = "";
-    if (block.type === "resource_link") part = `@${block.uri.replace(/^file:\/\//, "")}`;
-    else if (block.type === "resource") {
-      const { resource } = block;
-      const where = resource.uri.replace(/^file:\/\//, "");
-      part = "text" in resource ? `
-<file path="${where}">
-${resource.text}
-</file>
-` : `@${where}`;
-    }
-    if (part && text && !/\s$/.test(text) && !part.startsWith("\n")) text += " ";
-    text += part;
-  }
-  return text.trim();
-}
-function shown(file, cwd) {
-  if (!cwd || !path.isAbsolute(file)) return file;
-  const relative = path.relative(cwd, file);
-  return relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : file;
-}
-function toolKind(item) {
-  const detail = item.detail;
-  switch (detail.type) {
-    case "read":
-      return "read";
-    case "edit":
-    case "write":
-      return "edit";
-    case "search":
-      return detail.toolName === "web_search" ? "fetch" : "search";
-    case "fetch":
-      return "fetch";
-    case "plan":
-      return "think";
-    case "sub_agent":
-    case "plain_text":
-      return "other";
-  }
-  const word = detail.type === "shell" ? String(detail.command ?? "").trim().split(/[\s{(]/)[0] : item.name;
-  if (/^(Read|NotebookRead|LS)$/.test(word)) return "read";
-  if (/^(Edit|MultiEdit|Write|NotebookEdit)$/.test(word)) return "edit";
-  if (/^(Grep|Glob)$/.test(word)) return "search";
-  if (/^(WebFetch|WebSearch)$/.test(word)) return "fetch";
-  if (/^(Skill|Task|TodoWrite)$/.test(word) || item.name.startsWith("alp_")) return "other";
-  return detail.type === "shell" ? "execute" : "other";
-}
-function toolTitle(item, cwd) {
-  const detail = item.detail;
-  switch (detail.type) {
-    case "shell":
-      return clip(String(detail.command ?? "").split("\n")[0], 160);
-    case "read":
-      return clip(`Read ${shown(detail.filePath, cwd)}`, 160);
-    case "edit":
-      return clip(`Edit ${shown(detail.filePath, cwd)}`, 160);
-    case "write":
-      return clip(`Write ${shown(detail.filePath, cwd)}`, 160);
-    case "search":
-      return clip(`${detail.toolName === "web_search" ? "Search the web" : "Search"} ${detail.query}`, 160);
-    case "fetch":
-      return clip(`Fetch ${detail.url}`, 160);
-    case "sub_agent":
-      return clip(`${detail.subAgentType ?? "Sub-agent"}${detail.description ? `: ${detail.description.split("\n")[0]}` : ""}`, 160);
-    case "plan":
-      return "Plan";
-    case "plain_text":
-      return clip(`${item.name}${detail.label ? `: ${detail.label}` : ""}`, 160);
-  }
-  const input = detail.input ?? {};
-  if (item.name === "alp_delegate") return clip(`Delegate to ${input.agent ?? "an agent"}: ${String(input.task ?? "").split("\n")[0]}`, 160);
-  return clip(`${item.name} ${JSON.stringify(input)}`, 160);
-}
-var bounded = (text) => text.length > OUTPUT_CHARS ? `${text.slice(0, OUTPUT_CHARS)}
-\u2026 (${text.length - OUTPUT_CHARS} more characters)` : text;
-function toolOutput(item) {
-  const detail = item.detail;
-  const parts = [];
-  let text = "";
-  switch (detail.type) {
-    case "shell":
-      text = detail.output ?? "";
-      break;
-    case "read":
-      text = detail.content ?? "";
-      break;
-    case "edit":
-      if (detail.newString !== void 0 || detail.oldString !== void 0) parts.push({ type: "diff", path: detail.filePath, oldText: detail.oldString ?? null, newText: detail.newString ?? "" });
-      else if (detail.unifiedDiff) text = "```diff\n" + detail.unifiedDiff + (detail.unifiedDiff.endsWith("\n") ? "" : "\n") + "```";
-      break;
-    case "write":
-      if (detail.content !== void 0) parts.push({ type: "diff", path: detail.filePath, oldText: null, newText: detail.content });
-      break;
-    case "search":
-      text = detail.content ?? [...detail.filePaths ?? [], ...(detail.webResults ?? []).map((hit) => `${hit.title} \u2014 ${hit.url}`)].join("\n");
-      break;
-    case "fetch":
-      text = detail.result ?? "";
-      break;
-    case "sub_agent":
-      text = detail.log || detail.description || "";
-      break;
-    case "plan":
-      text = detail.text;
-      break;
-    case "plain_text":
-      text = detail.text ?? "";
-      break;
-    default: {
-      const output = detail.output;
-      text = Array.isArray(output) ? output.map((part) => typeof part?.text === "string" ? part.text : JSON.stringify(part)).join("\n") : output == null ? "" : typeof output === "string" ? output : JSON.stringify(output, null, 2);
-    }
-  }
-  if (item.error) text = text ? `${text}
-${item.error}` : item.error;
-  if (text) parts.push({ type: "content", content: { type: "text", text: bounded(text) } });
-  return parts.map((part) => part.type === "diff" ? { ...part, newText: bounded(part.newText), ...part.oldText ? { oldText: bounded(part.oldText) } : {} } : part);
-}
-function toolInput(item) {
-  const detail = item.detail;
-  if (detail.type === "shell") return { command: detail.command, cwd: detail.cwd };
-  if (detail.type === "unknown" || !["read", "edit", "write", "search", "fetch", "sub_agent", "plan", "plain_text"].includes(detail.type)) return detail.input;
-  const { type: _type, content: _content, oldString: _old, newString: _new, unifiedDiff: _diff, result: _result, log: _log, text: _text, filePaths: _paths, webResults: _hits, ...rest } = detail;
-  return rest;
-}
-function toolLocations(item) {
-  const detail = item.detail;
-  if (detail.type !== "read" && detail.type !== "edit" && detail.type !== "write") return void 0;
-  const filePath = String(detail.filePath);
-  return [{ path: filePath, ...detail.type === "read" && typeof detail.offset === "number" ? { line: detail.offset } : {} }];
-}
-var clip = (text, chars) => text.length > chars ? `${text.slice(0, chars - 1)}\u2026` : text;
-var status = (state) => state === "running" ? "in_progress" : state;
-function createAcpAgent(options) {
-  const log = options.log ?? (() => {
-  });
-  const sessions = /* @__PURE__ */ new Map();
-  let alpd;
-  let editor;
-  let leaving = false;
-  async function daemon() {
-    alpd ??= options.connect().then((connection) => {
-      connection.onEvent(project);
-      connection.onClose((error) => {
-        if (leaving) return;
-        log("lost the connection to alpd", { code: "ALP_IPC_LOST", error });
-        alpd = void 0;
-        for (const session of sessions.values()) {
-          session.opened = false;
-          session.waiting?.done({ state: "failed", error: `ALP lost its connection to alpd: ${error.message}` });
-        }
-      });
-      return connection;
-    }, (error) => {
-      alpd = void 0;
-      log("could not reach alpd", { code: "ALP_IPC_CONNECT_FAILED", error });
-      throw error;
-    });
-    return alpd;
-  }
-  const request = async (method, params) => (await daemon()).request(method, params);
-  function send(session, update) {
-    const client = editor;
-    if (!client) return;
-    session.queue = session.queue.then(() => client.notify("session/update", { sessionId: session.id, update })).catch((error) => log("could not send an update to the editor", { code: "ALP_ACP_UPDATE_FAILED", error }));
-  }
-  const say = (session, text) => send(session, { sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
-  function configOptions(session) {
-    const teams = session.opened ? choices(session).filter((team) => team.id === session.preview.team) : choices(session);
-    return [
-      {
-        id: "team",
-        name: "Team",
-        category: "model",
-        type: "select",
-        currentValue: session.preview.team,
-        description: session.opened ? "A session keeps its team; start a new one for another team" : "The team that works on this session",
-        options: teams.map((team) => ({ value: team.id, name: team.label, ...team.description ? { description: team.description } : {} }))
-      },
-      { id: "mode", name: "Permissions", category: "mode", type: "select", currentValue: session.preview.mode, options: MODES.map((mode) => ({ value: mode.id, name: mode.name, description: mode.description })) }
-    ];
-  }
-  function choices(session) {
-    const { teams, team } = session.preview;
-    const own = unlistedOf(session.preview);
-    const first = session.unlisted && session.unlisted.id !== team && !teams.some((entry) => entry.id === session.unlisted.id) ? [session.unlisted] : [];
-    return [...first, ...own ? [own] : [], ...teams];
-  }
-  const modeState = (session) => ({ currentModeId: session.preview.mode, availableModes: MODES });
-  function track(id, cwd, mcpServers, preview2, opened) {
-    const unlisted = unlistedOf(preview2);
-    const session = { id, cwd, mcpServers, preview: preview2, opened, ...unlisted ? { unlisted } : {}, ours: /* @__PURE__ */ new Set(), texts: /* @__PURE__ */ new Map(), tools: /* @__PURE__ */ new Set(), questions: /* @__PURE__ */ new Map(), queue: Promise.resolve() };
-    sessions.set(id, session);
-    return session;
-  }
-  function known(sessionId) {
-    const session = sessions.get(sessionId);
-    if (!session) throw acp.RequestError.resourceNotFound(sessionId);
-    return session;
-  }
-  function project(envelope) {
-    const session = sessions.get(envelope.sessionId);
-    const { event } = envelope;
-    if (event.type === "question") {
-      const root = sessions.get(event.question.rootId);
-      if (!root || root.questions.has(event.question.id)) return;
-      root.questions.set(event.question.id, event.question);
-      const options2 = event.question.options?.length ? `
-Options: ${event.question.options.join(" \xB7 ")}` : "";
-      say(root, `
-
-**${event.question.agent} asks you:** ${event.question.body}${options2}
-
-Reply with /answer <your answer>, or /dismiss.
-
-`);
-      return;
-    }
-    if (event.type === "question.resolved") {
-      for (const root of sessions.values()) root.questions.delete(event.questionId);
-      return;
-    }
-    if (!session) return;
-    switch (event.type) {
-      case "session.updated":
-        if (event.session.mode !== session.preview.mode) {
-          session.preview = { ...session.preview, mode: event.session.mode };
-          send(session, { sessionUpdate: "current_mode_update", currentModeId: event.session.mode });
-          send(session, { sessionUpdate: "config_option_update", configOptions: configOptions(session) });
-        }
-        return;
-      case "prompt.accepted":
-        if (session.waiting?.clientMessageId === event.clientMessageId) session.waiting.turnId = event.turnId;
-        return;
-      case "prompt.failed":
-        if (session.waiting?.clientMessageId === event.clientMessageId) session.waiting.done({ state: "failed", error: event.error.message });
-        return;
-      case "turn.ended":
-        if (session.waiting?.turnId === event.turnId) session.waiting.done({ state: event.state, ...event.error ? { error: event.error.message } : {} });
-        return;
-      case "session.failed":
-        session.opened = false;
-        session.waiting?.done({ state: "failed", error: event.error.message });
-        return;
-      case "session.closed":
-        session.opened = false;
-        return;
-      case "item":
-        item(session, event.item);
-        return;
-    }
-  }
-  function item(session, item2) {
-    switch (item2.kind) {
-      case "user_message": {
-        if (item2.clientMessageId && session.ours.has(item2.clientMessageId)) return;
-        if (item2.clientMessageId?.startsWith("alp-") || item2.id.startsWith("user:alp-")) {
-          send(session, { sessionUpdate: "tool_call", toolCallId: item2.id, title: clip(`ALP: ${item2.text.split("\n").find((line) => line.trim()) ?? "note"}`, 160), kind: "other", status: "completed", content: [{ type: "content", content: { type: "text", text: item2.text } }] });
-          return;
-        }
-        send(session, { sessionUpdate: "user_message_chunk", content: { type: "text", text: item2.text } });
-        return;
-      }
-      case "assistant_message": {
-        const before = session.texts.get(item2.id) ?? "";
-        session.texts.set(item2.id, item2.text);
-        const fresh = item2.text.startsWith(before) ? item2.text.slice(before.length) : `
-${item2.text}`;
-        if (fresh) say(session, fresh);
-        return;
-      }
-      case "notice":
-        say(session, `
-
-> ALP: ${item2.text}
-
-`);
-        return;
-      case "compaction":
-        if (item2.status !== "running") say(session, `
-
-> ALP: ${item2.status === "completed" ? `the context was compacted${item2.preTokens ? ` from ${Math.round(item2.preTokens / 1e3)}k tokens` : ""}` : "compacting the context failed"}
-
-`);
-        return;
-      case "todo":
-        send(session, { sessionUpdate: "plan", entries: item2.items.map((entry) => ({ content: entry.text, priority: "medium", status: entry.status })) });
-        return;
-      case "tool_call": {
-        const locations = toolLocations(item2);
-        const fields = { title: toolTitle(item2, session.cwd), kind: toolKind(item2), status: status(item2.status), content: toolOutput(item2), rawInput: toolInput(item2), ...locations ? { locations } : {} };
-        if (session.tools.has(item2.id)) send(session, { sessionUpdate: "tool_call_update", toolCallId: item2.id, ...fields });
-        else {
-          session.tools.add(item2.id);
-          send(session, { sessionUpdate: "tool_call", toolCallId: item2.id, ...fields });
-        }
-        return;
-      }
-    }
-  }
-  async function open(session, resume) {
-    await request("session.create", {
-      sessionId: session.id,
-      spec: { cwd: session.cwd, persist: true, workflow: session.preview.team, mode: session.preview.mode, mcpServers: session.mcpServers },
-      history: "skip",
-      ...resume ? { resume: true } : {}
-    });
-    session.opened = true;
-  }
-  async function prompt(session, blocks) {
-    const text = promptText(blocks);
-    const command = /^\/(answer|dismiss)\b\s*([\s\S]*)$/.exec(text);
-    if (command) {
-      const [question] = session.questions.values();
-      if (!question) say(session, "No agent is waiting for an answer from you.");
-      else {
-        await request("question.answer", command[1] === "answer" ? { questionId: question.id, text: command[2].trim() || "yes" } : { questionId: question.id, dismiss: true, ...command[2].trim() ? { reason: command[2].trim() } : {} });
-        session.questions.delete(question.id);
-        say(session, command[1] === "answer" ? `Sent your answer to ${question.agent}.` : `Dismissed ${question.agent}'s question.`);
-      }
-      await session.queue;
-      return { stopReason: "end_turn" };
-    }
-    if (!text) throw acp.RequestError.invalidParams(void 0, "The prompt is empty");
-    if (!session.opened) {
-      const { session: snapshot } = await request("session.get", { sessionId: session.id }).catch(() => ({ session: void 0 }));
-      await open(session, !!snapshot);
-      send(session, { sessionUpdate: "config_option_update", configOptions: configOptions(session) });
-    }
-    if (session.waiting) throw acp.RequestError.invalidRequest(void 0, "A prompt is already running in this session");
-    const clientMessageId = randomUUID();
-    session.ours.add(clientMessageId);
-    let done;
-    const ended = new Promise((resolve) => {
-      done = (result2) => {
-        if (session.waiting?.clientMessageId === clientMessageId) session.waiting = void 0;
-        resolve(result2);
-      };
-    });
-    session.waiting = { clientMessageId, done };
-    try {
-      await request("session.prompt", { sessionId: session.id, clientMessageId, delivery: "auto", content: [{ type: "text", text }] });
-    } catch (error) {
-      done({ state: "failed", error: error instanceof Error ? error.message : String(error) });
-    }
-    const result = await ended;
-    await session.queue;
-    if (result.state === "canceled") return { stopReason: "cancelled" };
-    if (result.state === "failed") throw acp.RequestError.internalError(void 0, result.error ?? "The turn failed");
-    return { stopReason: "end_turn" };
-  }
-  async function preview(cwd, mcpServers, team, mode) {
-    const { preview: preview2 } = await request("session.preview", { spec: { cwd, mcpServers, ...team ? { workflow: team } : {}, ...mode ? { mode } : {} } });
-    return preview2;
-  }
-  const absolute = (cwd) => {
-    if (!path.isAbsolute(cwd)) throw acp.RequestError.invalidParams(void 0, "cwd must be an absolute path");
-    return path.resolve(cwd);
-  };
-  return acp.agent({ name: "alp" }).onConnect((connection) => {
-    editor = connection.client;
-    void connection.closed.then(() => release());
-  }).onRequest("initialize", () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: {
-      loadSession: true,
-      promptCapabilities: { embeddedContext: true },
-      mcpCapabilities: { http: true, sse: true },
-      sessionCapabilities: { list: {}, close: {} }
-    },
-    agentInfo: { name: "alp", title: "ALP", version: options.version },
-    authMethods: []
-  })).onRequest("authenticate", () => ({})).onRequest("session/new", async ({ params }) => {
-    const cwd = absolute(params.cwd);
-    const mcpServers = hostServers(params.mcpServers);
-    const session = track(`acp-${randomUUID()}`, cwd, mcpServers, await preview(cwd, mcpServers), false);
-    queueMicrotask(() => send(session, { sessionUpdate: "available_commands_update", availableCommands: COMMANDS }));
-    return { sessionId: session.id, configOptions: configOptions(session), modes: modeState(session) };
-  }).onRequest("session/load", async ({ params }) => {
-    const cwd = absolute(params.cwd);
-    const { session: record } = await request("session.get", { sessionId: params.sessionId }).catch(() => {
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    });
-    if (record.parentId || path.resolve(record.projectRoot) !== cwd) throw acp.RequestError.invalidParams(void 0, "That ALP session belongs to another project");
-    const session = track(params.sessionId, cwd, hostServers(params.mcpServers), {
-      teams: [{ id: record.workflow?.mode ?? "pho", label: record.teamLabel ?? record.workflow?.mode ?? "pho" }],
-      team: record.workflow?.mode ?? "pho",
-      ...record.teamLabel ? { teamLabel: record.teamLabel } : {},
-      agent: record.agent,
-      runtime: record.runtime,
-      model: record.model,
-      mode: record.mode,
-      thinking: record.thinking
-    }, true);
-    const live = record.status === "idle" || record.status === "running";
-    await request("session.attach", { sessionId: session.id, replay: true });
-    session.opened = live;
-    await session.queue;
-    send(session, { sessionUpdate: "available_commands_update", availableCommands: COMMANDS });
-    return { configOptions: configOptions(session), modes: modeState(session) };
-  }).onRequest("session/list", async ({ params }) => {
-    const { sessions: rows } = await request("session.list", { ...params.cwd ? { projectRoot: path.resolve(params.cwd) } : {}, rootsOnly: true, includeClosed: true });
-    return {
-      sessions: rows.filter((row) => row.persistent).slice(0, 100).map((row) => ({
-        sessionId: row.id,
-        cwd: row.projectRoot,
-        title: row.title ?? `ALP ${row.agent}`,
-        ...row.updatedAt ? { updatedAt: row.updatedAt } : {}
-      }))
-    };
-  }).onRequest("session/prompt", ({ params }) => prompt(known(params.sessionId), params.prompt)).onNotification("session/cancel", async ({ params }) => {
-    const session = sessions.get(params.sessionId);
-    if (!session?.opened) return;
-    await request("session.interrupt", { sessionId: session.id }).catch((error) => log("session.interrupt failed", { code: "ALP_ACP_INTERRUPT_FAILED", error }));
-  }).onRequest("session/set_mode", async ({ params }) => {
-    await setMode(known(params.sessionId), params.modeId);
-    return {};
-  }).onRequest("session/set_config_option", async ({ params }) => {
-    const session = known(params.sessionId);
-    const value = String(params.value);
-    if (params.configId === "mode") await setMode(session, value);
-    else if (params.configId === "team") {
-      if (session.opened && value !== session.preview.team) throw acp.RequestError.invalidParams(void 0, "A session keeps its team; start a new one for another team");
-      if (!choices(session).some((team) => team.id === value)) throw acp.RequestError.invalidParams(void 0, `Unknown team ${value}`);
-      session.preview = { ...await preview(session.cwd, session.mcpServers, value), mode: session.preview.mode };
-    } else throw acp.RequestError.invalidParams(void 0, `Unknown option ${params.configId}`);
-    return { configOptions: configOptions(session) };
-  }).onRequest("session/close", async ({ params }) => {
-    const session = known(params.sessionId);
-    sessions.delete(session.id);
-    if (session.opened) await request("session.release", { sessionId: session.id }).catch(() => {
-    });
-    return {};
-  });
-  async function setMode(session, mode) {
-    if (!MODES.some((entry) => entry.id === mode)) throw acp.RequestError.invalidParams(void 0, `Unknown mode ${mode}`);
-    if (session.opened) await request("session.configure", { sessionId: session.id, mode });
-    session.preview = { ...session.preview, mode };
-  }
-  async function release() {
-    leaving = true;
-    const connection = await alpd?.catch(() => void 0);
-    if (!connection) return;
-    await Promise.all([...sessions.values()].filter((session) => session.opened).map((session) => connection.request("session.release", { sessionId: session.id }).catch(() => {
-    })));
-    sessions.clear();
-    connection.close();
-  }
-}
-export {
-  createAcpAgent,
-  hostServers,
-  promptText,
-  toolInput,
-  toolKind,
-  toolLocations,
-  toolOutput,
-  toolTitle
-};

package/packages/cli/dist/acp/main.d.ts

@@ -1,4 +0,0 @@
-/** `alp acp`: serves the Agent Client Protocol on stdio until the editor closes it (ALPD §60). */
-export declare function runAcp({ daemonEntry }: {
-    daemonEntry: string;
-}): Promise<void>;

package/packages/cli/dist/acp/main.js

@@ -1,23 +0,0 @@
-// packages/cli/src/acp/main.ts
-import * as acp from "@agentclientprotocol/sdk";
-import { Readable, Writable } from "node:stream";
-import { alpHome, connect } from "@anhlp/alp-client/index";
-import { startDaemon } from "@anhlp/alp-client/supervise";
-import { createLogger } from "@anhlp/alp-core/log";
-import { createAcpAgent } from "./agent.js";
-async function runAcp({ daemonEntry }) {
-  const version = true ? "0.0.1-beta.4" : "0.0.0";
-  const logger = createLogger({ component: "acp" });
-  const log = (message, fields) => logger.warn(message, fields);
-  const app = createAcpAgent({
-    version,
-    log,
-    connect: async () => connect(await startDaemon({ home: alpHome(), entry: daemonEntry }), { name: "alp-acp", version })
-  });
-  const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-  const connection = app.connect(stream);
-  await connection.closed;
-}
-export {
-  runAcp
-};