@openacp/cli 0.4.11 → 0.5.1

package/README.md

@@ -9,8 +9,10 @@ One message, any channel, any agent.
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js >= 20](https://img.shields.io/badge/Node.js-%3E%3D%2020-green.svg)](https://nodejs.org/)
 [![ACP Protocol](https://img.shields.io/badge/Protocol-ACP-purple.svg)](https://agentclientprotocol.org/)
+[![npm](https://img.shields.io/npm/v/@openacp/cli.svg)](https://www.npmjs.com/package/@openacp/cli)
+[![Twitter Follow](https://img.shields.io/twitter/follow/Open_ACP?style=social)](https://x.com/Open_ACP)
 
-[Getting Started](docs/guide/getting-started.md) | [Usage](docs/guide/usage.md) | [Configuration](docs/guide/configuration.md) | [Tunnel](docs/guide/tunnel.md) | [Plugins](docs/guide/plugins.md) | [Development](docs/guide/development.md)
+[Getting Started](docs/guide/getting-started.md) | [Agents](docs/guide/agents.md) | [Usage](docs/guide/usage.md) | [Configuration](docs/guide/configuration.md) | [Tunnel](docs/guide/tunnel.md) | [Plugins](docs/guide/plugins.md) | [Development](docs/guide/development.md)
 
 </div>
 
@@ -47,9 +49,32 @@ AI Agent (Claude Code, Codex, ...)            File/Diff Viewer
 </table>
 </div>
 
+## Supported Agents
+
+OpenACP follows the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) standard — an open protocol for connecting AI coding agents to client applications. Agent definitions are loaded from the [official ACP Registry](https://agentclientprotocol.com/get-started/registry) via CDN ([`registry.json`](https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json)), so new agents are available as soon as they're registered.
+
+| Agent | Distribution | Description |
+|-------|-------------|-------------|
+| [Claude Agent](https://github.com/anthropics/claude-code) | npx | Anthropic's Claude coding agent |
+| [Gemini CLI](https://github.com/google-gemini/gemini-cli) | npx | Google's official CLI for Gemini |
+| [Codex CLI](https://github.com/openai/codex) | npx | OpenAI's coding assistant |
+| [GitHub Copilot](https://github.com/github/copilot-cli) | npx | GitHub's AI pair programmer |
+| [Cursor](https://www.cursor.com/) | binary | Cursor's coding agent |
+| [Cline](https://github.com/cline/cline) | npx | Autonomous coding agent with file editing, commands, and browser |
+| [goose](https://github.com/block/goose) | binary | Open source AI agent for engineering tasks |
+| [Amp](https://github.com/tao12345666333/amp-acp) | binary | The frontier coding agent |
+| [Auggie CLI](https://www.augmentcode.com/) | npx | Augment Code's agent with industry-leading context engine |
+| [Junie](https://www.jetbrains.com/) | binary | AI coding agent by JetBrains |
+| [Kilo](https://github.com/kilocode/kilo) | npx | The open source coding agent |
+| [Qwen Code](https://github.com/QwenLM/qwen-code) | npx | Alibaba's Qwen coding assistant |
+| [crow-cli](https://github.com/crowdecode/crow-cli) | uvx | Minimal ACP native coding agent |
+| ...and more | | [See full registry →](https://agentclientprotocol.com/get-started/registry) |
+
+> **28+ agents supported** — any agent registered in the ACP Registry works out of the box. Install with `openacp agents install <name>` or browse from Telegram with `/agents`.
+
 ## Features
 
-- **Multi-agent** — Claude Code, Codex, or any ACP-compatible agent
+- **Multi-agent** — Claude Code, Codex, Gemini, Cursor, and [28+ ACP-compatible agents](#supported-agents)
 - **Telegram** — Forum topics, real-time streaming, permission buttons, skill commands
 - **Tunnel & file viewer** — Public file/diff viewer via Cloudflare, ngrok, bore, or Tailscale
 - **Session persistence** — Resume sessions across restarts
@@ -102,6 +127,14 @@ openacp logs
 ### Other CLI commands
 
 ```bash
+# Agent management
+openacp agents                    # List all agents (installed + available)
+openacp agents install <name>     # Install an agent from the ACP Registry
+openacp agents uninstall <name>   # Remove an installed agent
+openacp agents info <name>        # Show agent details & dependencies
+openacp agents refresh            # Force-refresh the registry
+
+# System
 openacp config            # Show current config
 openacp reset             # Re-run the setup wizard
 openacp update            # Update to latest version
@@ -120,7 +153,8 @@ Once OpenACP is running, control it from Telegram:
 | `/newchat` | New session, same agent & workspace |
 | `/cancel` | Cancel current session |
 | `/status` | Show session or system status |
-| `/agents` | List available agents |
+| `/agents` | Browse & install agents from ACP Registry |
+| `/install <name>` | Install an agent directly |
 
 Each session gets its own forum topic. The agent streams responses in real time, shows tool calls, and asks for permission when needed.
 
@@ -165,6 +199,10 @@ Sessions are not locked after transfer — you can continue from either side.
 
 See [development guide](docs/guide/development.md).
 
+## Follow Us
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/Open_ACP?style=social)](https://x.com/Open_ACP)
+
 ## License
 
 [MIT](LICENSE)

package/dist/agent-catalog-LAAVBVLY.js

@@ -0,0 +1,10 @@
+import {
+  AgentCatalog
+} from "./chunk-5MH66WUY.js";
+import "./chunk-5HGXUCMX.js";
+import "./chunk-GUHCS6X7.js";
+import "./chunk-ESOPMQAY.js";
+export {
+  AgentCatalog
+};
+//# sourceMappingURL=agent-catalog-LAAVBVLY.js.map

package/dist/agent-dependencies-FCLRGMZM.js

@@ -0,0 +1,23 @@
+import {
+  REGISTRY_AGENT_ALIASES,
+  checkDependencies,
+  checkRuntimeAvailable,
+  commandExists,
+  getAgentAlias,
+  getAgentCapabilities,
+  getAgentDependencies,
+  getAgentSetup,
+  listAgentsWithIntegration
+} from "./chunk-GUHCS6X7.js";
+export {
+  REGISTRY_AGENT_ALIASES,
+  checkDependencies,
+  checkRuntimeAvailable,
+  commandExists,
+  getAgentAlias,
+  getAgentCapabilities,
+  getAgentDependencies,
+  getAgentSetup,
+  listAgentsWithIntegration
+};
+//# sourceMappingURL=agent-dependencies-FCLRGMZM.js.map

package/dist/agent-registry-KZANAFXQ.js

@@ -0,0 +1,8 @@
+import "./chunk-NAMYZIS5.js";
+import {
+  getAgentCapabilities
+} from "./chunk-GUHCS6X7.js";
+export {
+  getAgentCapabilities
+};
+//# sourceMappingURL=agent-registry-KZANAFXQ.js.map

package/dist/agent-store-ZBXGOFPH.js

@@ -0,0 +1,8 @@
+import {
+  AgentStore
+} from "./chunk-5HGXUCMX.js";
+import "./chunk-ESOPMQAY.js";
+export {
+  AgentStore
+};
+//# sourceMappingURL=agent-store-ZBXGOFPH.js.map

package/dist/chunk-5HGXUCMX.js

@@ -0,0 +1,83 @@
+import {
+  createChildLogger
+} from "./chunk-ESOPMQAY.js";
+
+// src/core/agent-store.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { z } from "zod";
+var log = createChildLogger({ module: "agent-store" });
+var InstalledAgentSchema = z.object({
+  registryId: z.string().nullable(),
+  name: z.string(),
+  version: z.string(),
+  distribution: z.enum(["npx", "uvx", "binary", "custom"]),
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string(), z.string()).default({}),
+  workingDirectory: z.string().optional(),
+  installedAt: z.string(),
+  binaryPath: z.string().nullable().default(null)
+});
+var AgentStoreSchema = z.object({
+  version: z.number().default(1),
+  installed: z.record(z.string(), InstalledAgentSchema).default({})
+});
+var AgentStore = class {
+  data = { version: 1, installed: {} };
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath ?? path.join(os.homedir(), ".openacp", "agents.json");
+  }
+  load() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    if (!fs.existsSync(this.filePath)) {
+      this.data = { version: 1, installed: {} };
+      return;
+    }
+    try {
+      const raw = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+      const result = AgentStoreSchema.safeParse(raw);
+      if (result.success) {
+        this.data = result.data;
+      } else {
+        log.warn({ errors: result.error.issues }, "Invalid agents.json, starting fresh");
+        this.data = { version: 1, installed: {} };
+      }
+    } catch (err) {
+      log.warn({ err }, "Failed to read agents.json, starting fresh");
+      this.data = { version: 1, installed: {} };
+    }
+  }
+  exists() {
+    return fs.existsSync(this.filePath);
+  }
+  getInstalled() {
+    return this.data.installed;
+  }
+  getAgent(key) {
+    return this.data.installed[key];
+  }
+  addAgent(key, agent) {
+    this.data.installed[key] = agent;
+    this.save();
+  }
+  removeAgent(key) {
+    delete this.data.installed[key];
+    this.save();
+  }
+  hasAgent(key) {
+    return key in this.data.installed;
+  }
+  save() {
+    const tmpPath = this.filePath + ".tmp";
+    fs.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2));
+    fs.renameSync(tmpPath, this.filePath);
+  }
+};
+
+export {
+  AgentStore
+};
+//# sourceMappingURL=chunk-5HGXUCMX.js.map

package/dist/chunk-5HGXUCMX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/agent-store.ts"],"sourcesContent":["import * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport * as os from \"node:os\";\nimport { z } from \"zod\";\nimport type { InstalledAgent } from \"./types.js\";\nimport { createChildLogger } from \"./log.js\";\n\nconst log = createChildLogger({ module: \"agent-store\" });\n\nconst InstalledAgentSchema = z.object({\n  registryId: z.string().nullable(),\n  name: z.string(),\n  version: z.string(),\n  distribution: z.enum([\"npx\", \"uvx\", \"binary\", \"custom\"]),\n  command: z.string(),\n  args: z.array(z.string()).default([]),\n  env: z.record(z.string(), z.string()).default({}),\n  workingDirectory: z.string().optional(),\n  installedAt: z.string(),\n  binaryPath: z.string().nullable().default(null),\n});\n\nconst AgentStoreSchema = z.object({\n  version: z.number().default(1),\n  installed: z.record(z.string(), InstalledAgentSchema).default({}),\n});\n\ntype AgentStoreData = z.infer<typeof AgentStoreSchema>;\n\nexport class AgentStore {\n  private data: AgentStoreData = { version: 1, installed: {} };\n  private filePath: string;\n\n  constructor(filePath?: string) {\n    this.filePath = filePath ?? path.join(os.homedir(), \".openacp\", \"agents.json\");\n  }\n\n  load(): void {\n    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });\n\n    if (!fs.existsSync(this.filePath)) {\n      this.data = { version: 1, installed: {} };\n      return;\n    }\n\n    try {\n      const raw = JSON.parse(fs.readFileSync(this.filePath, \"utf-8\") as string);\n      const result = AgentStoreSchema.safeParse(raw);\n      if (result.success) {\n        this.data = result.data;\n      } else {\n        log.warn({ errors: result.error.issues }, \"Invalid agents.json, starting fresh\");\n        this.data = { version: 1, installed: {} };\n      }\n    } catch (err) {\n      log.warn({ err }, \"Failed to read agents.json, starting fresh\");\n      this.data = { version: 1, installed: {} };\n    }\n  }\n\n  exists(): boolean {\n    return fs.existsSync(this.filePath);\n  }\n\n  getInstalled(): Record<string, InstalledAgent> {\n    return this.data.installed;\n  }\n\n  getAgent(key: string): InstalledAgent | undefined {\n    return this.data.installed[key];\n  }\n\n  addAgent(key: string, agent: InstalledAgent): void {\n    this.data.installed[key] = agent;\n    this.save();\n  }\n\n  removeAgent(key: string): void {\n    delete this.data.installed[key];\n    this.save();\n  }\n\n  hasAgent(key: string): boolean {\n    return key in this.data.installed;\n  }\n\n  private save(): void {\n    const tmpPath = this.filePath + \".tmp\";\n    fs.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2));\n    fs.renameSync(tmpPath, this.filePath);\n  }\n}\n"],"mappings":";;;;;AAAA,YAAY,QAAQ;AACpB,YAAY,UAAU;AACtB,YAAY,QAAQ;AACpB,SAAS,SAAS;AAIlB,IAAM,MAAM,kBAAkB,EAAE,QAAQ,cAAc,CAAC;AAEvD,IAAM,uBAAuB,EAAE,OAAO;AAAA,EACpC,YAAY,EAAE,OAAO,EAAE,SAAS;AAAA,EAChC,MAAM,EAAE,OAAO;AAAA,EACf,SAAS,EAAE,OAAO;AAAA,EAClB,cAAc,EAAE,KAAK,CAAC,OAAO,OAAO,UAAU,QAAQ,CAAC;AAAA,EACvD,SAAS,EAAE,OAAO;AAAA,EAClB,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,EACpC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;AAAA,EAChD,kBAAkB,EAAE,OAAO,EAAE,SAAS;AAAA,EACtC,aAAa,EAAE,OAAO;AAAA,EACtB,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,IAAI;AAChD,CAAC;AAED,IAAM,mBAAmB,EAAE,OAAO;AAAA,EAChC,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC;AAAA,EAC7B,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,oBAAoB,EAAE,QAAQ,CAAC,CAAC;AAClE,CAAC;AAIM,IAAM,aAAN,MAAiB;AAAA,EACd,OAAuB,EAAE,SAAS,GAAG,WAAW,CAAC,EAAE;AAAA,EACnD;AAAA,EAER,YAAY,UAAmB;AAC7B,SAAK,WAAW,YAAiB,UAAQ,WAAQ,GAAG,YAAY,aAAa;AAAA,EAC/E;AAAA,EAEA,OAAa;AACX,IAAG,aAAe,aAAQ,KAAK,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAE7D,QAAI,CAAI,cAAW,KAAK,QAAQ,GAAG;AACjC,WAAK,OAAO,EAAE,SAAS,GAAG,WAAW,CAAC,EAAE;AACxC;AAAA,IACF;AAEA,QAAI;AACF,YAAM,MAAM,KAAK,MAAS,gBAAa,KAAK,UAAU,OAAO,CAAW;AACxE,YAAM,SAAS,iBAAiB,UAAU,GAAG;AAC7C,UAAI,OAAO,SAAS;AAClB,aAAK,OAAO,OAAO;AAAA,MACrB,OAAO;AACL,YAAI,KAAK,EAAE,QAAQ,OAAO,MAAM,OAAO,GAAG,qCAAqC;AAC/E,aAAK,OAAO,EAAE,SAAS,GAAG,WAAW,CAAC,EAAE;AAAA,MAC1C;AAAA,IACF,SAAS,KAAK;AACZ,UAAI,KAAK,EAAE,IAAI,GAAG,4CAA4C;AAC9D,WAAK,OAAO,EAAE,SAAS,GAAG,WAAW,CAAC,EAAE;AAAA,IAC1C;AAAA,EACF;AAAA,EAEA,SAAkB;AAChB,WAAU,cAAW,KAAK,QAAQ;AAAA,EACpC;AAAA,EAEA,eAA+C;AAC7C,WAAO,KAAK,KAAK;AAAA,EACnB;AAAA,EAEA,SAAS,KAAyC;AAChD,WAAO,KAAK,KAAK,UAAU,GAAG;AAAA,EAChC;AAAA,EAEA,SAAS,KAAa,OAA6B;AACjD,SAAK,KAAK,UAAU,GAAG,IAAI;AAC3B,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,YAAY,KAAmB;AAC7B,WAAO,KAAK,KAAK,UAAU,GAAG;AAC9B,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,SAAS,KAAsB;AAC7B,WAAO,OAAO,KAAK,KAAK;AAAA,EAC1B;AAAA,EAEQ,OAAa;AACnB,UAAM,UAAU,KAAK,WAAW;AAChC,IAAG,iBAAc,SAAS,KAAK,UAAU,KAAK,MAAM,MAAM,CAAC,CAAC;AAC5D,IAAG,cAAW,SAAS,KAAK,QAAQ;AAAA,EACtC;AACF;","names":[]}

package/dist/chunk-5MH66WUY.js

@@ -0,0 +1,424 @@
+import {
+  AgentStore
+} from "./chunk-5HGXUCMX.js";
+import {
+  checkDependencies,
+  checkRuntimeAvailable,
+  getAgentAlias,
+  getAgentSetup
+} from "./chunk-GUHCS6X7.js";
+import {
+  createChildLogger
+} from "./chunk-ESOPMQAY.js";
+
+// src/core/agent-catalog.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+
+// src/core/agent-installer.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var log = createChildLogger({ module: "agent-installer" });
+var AGENTS_DIR = path.join(os.homedir(), ".openacp", "agents");
+var ARCH_MAP = {
+  arm64: "aarch64",
+  x64: "x86_64"
+};
+var PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows"
+};
+function getPlatformKey() {
+  const platform = PLATFORM_MAP[process.platform] ?? process.platform;
+  const arch = ARCH_MAP[process.arch] ?? process.arch;
+  return `${platform}-${arch}`;
+}
+function resolveDistribution(agent) {
+  const dist = agent.distribution;
+  if (dist.npx) {
+    return { type: "npx", package: dist.npx.package, args: dist.npx.args ?? [], env: dist.npx.env };
+  }
+  if (dist.uvx) {
+    return { type: "uvx", package: dist.uvx.package, args: dist.uvx.args ?? [], env: dist.uvx.env };
+  }
+  if (dist.binary) {
+    const platformKey = getPlatformKey();
+    const target = dist.binary[platformKey];
+    if (!target) return null;
+    return { type: "binary", archive: target.archive, cmd: target.cmd, args: target.args ?? [], env: target.env };
+  }
+  return null;
+}
+function buildInstalledAgent(registryId, name, version, dist, binaryPath) {
+  if (dist.type === "npx") {
+    return {
+      registryId,
+      name,
+      version,
+      distribution: "npx",
+      command: "npx",
+      args: [dist.package, ...dist.args],
+      env: dist.env ?? {},
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      binaryPath: null
+    };
+  }
+  if (dist.type === "uvx") {
+    return {
+      registryId,
+      name,
+      version,
+      distribution: "uvx",
+      command: "uvx",
+      args: [dist.package, ...dist.args],
+      env: dist.env ?? {},
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      binaryPath: null
+    };
+  }
+  const absCmd = path.resolve(binaryPath, dist.cmd);
+  return {
+    registryId,
+    name,
+    version,
+    distribution: "binary",
+    command: absCmd,
+    args: dist.args,
+    env: dist.env ?? {},
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    binaryPath
+  };
+}
+async function installAgent(agent, store, progress) {
+  const agentKey = getAgentAlias(agent.id);
+  await progress?.onStart(agent.id, agent.name);
+  await progress?.onStep("Checking requirements...");
+  const depResult = checkDependencies(agent.id);
+  if (!depResult.available) {
+    const hints = depResult.missing.map((m) => `  ${m.label}: ${m.installHint}`).join("\n");
+    const msg = `${agent.name} needs some tools installed first:
+${hints}`;
+    await progress?.onError(msg);
+    return { ok: false, agentKey, error: msg };
+  }
+  const dist = resolveDistribution(agent);
+  if (!dist) {
+    const platformKey = getPlatformKey();
+    const msg = `${agent.name} is not available for your system (${platformKey}). Check their website for other install options.`;
+    await progress?.onError(msg);
+    return { ok: false, agentKey, error: msg };
+  }
+  if (dist.type === "uvx" && !checkRuntimeAvailable("uvx")) {
+    const msg = `${agent.name} requires Python's uvx tool.
+Install it with: pip install uv`;
+    await progress?.onError(msg, "pip install uv");
+    return { ok: false, agentKey, error: msg, hint: "pip install uv" };
+  }
+  let binaryPath;
+  if (dist.type === "binary") {
+    try {
+      binaryPath = await downloadAndExtract(agent.id, dist.archive, progress);
+    } catch (err) {
+      const msg = `Failed to download ${agent.name}. Please try again or install manually.`;
+      await progress?.onError(msg);
+      return { ok: false, agentKey, error: msg };
+    }
+  } else {
+    await progress?.onStep("Setting up... (will download on first use)");
+  }
+  const installed = buildInstalledAgent(agent.id, agent.name, agent.version, dist, binaryPath);
+  store.addAgent(agentKey, installed);
+  const setup = getAgentSetup(agent.id);
+  await progress?.onSuccess(agent.name);
+  return { ok: true, agentKey, setupSteps: setup?.setupSteps };
+}
+async function downloadAndExtract(agentId, archiveUrl, progress) {
+  const destDir = path.join(AGENTS_DIR, agentId);
+  fs.mkdirSync(destDir, { recursive: true });
+  await progress?.onStep("Downloading...");
+  log.info({ agentId, url: archiveUrl }, "Downloading agent binary");
+  const response = await fetch(archiveUrl);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+  }
+  const contentLength = Number(response.headers.get("content-length") || 0);
+  const buffer = await readResponseWithProgress(response, contentLength, progress);
+  await progress?.onStep("Extracting...");
+  if (archiveUrl.endsWith(".zip")) {
+    await extractZip(buffer, destDir);
+  } else {
+    await extractTarGz(buffer, destDir);
+  }
+  await progress?.onStep("Ready!");
+  return destDir;
+}
+async function readResponseWithProgress(response, contentLength, progress) {
+  if (!response.body || contentLength === 0) {
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    received += value.length;
+    if (contentLength > 0) {
+      await progress?.onDownloadProgress(Math.round(received / contentLength * 100));
+    }
+  }
+  return Buffer.concat(chunks);
+}
+function validateExtractedPaths(destDir) {
+  const realDest = fs.realpathSync(destDir);
+  const entries = fs.readdirSync(destDir, { recursive: true, withFileTypes: true });
+  for (const entry of entries) {
+    const parentPath = entry.parentPath ?? entry.path;
+    const fullPath = path.join(parentPath, entry.name);
+    let realPath;
+    try {
+      realPath = fs.realpathSync(fullPath);
+    } catch {
+      const linkTarget = fs.readlinkSync(fullPath);
+      realPath = path.resolve(path.dirname(fullPath), linkTarget);
+    }
+    if (!realPath.startsWith(realDest + path.sep) && realPath !== realDest) {
+      fs.rmSync(destDir, { recursive: true, force: true });
+      throw new Error(`Archive contains unsafe path: ${entry.name}`);
+    }
+  }
+}
+async function extractTarGz(buffer, destDir) {
+  const { execFileSync } = await import("child_process");
+  const tmpFile = path.join(destDir, "_archive.tar.gz");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    execFileSync("tar", ["xzf", tmpFile, "-C", destDir], { stdio: "pipe" });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+  validateExtractedPaths(destDir);
+}
+async function extractZip(buffer, destDir) {
+  const { execFileSync } = await import("child_process");
+  const tmpFile = path.join(destDir, "_archive.zip");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    execFileSync("unzip", ["-o", tmpFile, "-d", destDir], { stdio: "pipe" });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+  validateExtractedPaths(destDir);
+}
+async function uninstallAgent(agentKey, store) {
+  const agent = store.getAgent(agentKey);
+  if (!agent) return;
+  if (agent.binaryPath && fs.existsSync(agent.binaryPath)) {
+    fs.rmSync(agent.binaryPath, { recursive: true, force: true });
+    log.info({ agentKey, binaryPath: agent.binaryPath }, "Deleted agent binary");
+  }
+  store.removeAgent(agentKey);
+}
+
+// src/core/agent-catalog.ts
+var log2 = createChildLogger({ module: "agent-catalog" });
+var REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+var CACHE_PATH = path2.join(os2.homedir(), ".openacp", "registry-cache.json");
+var DEFAULT_TTL_HOURS = 24;
+var AgentCatalog = class {
+  store;
+  registryAgents = [];
+  constructor(store) {
+    this.store = store ?? new AgentStore();
+  }
+  load() {
+    this.store.load();
+    this.loadRegistryFromCacheOrSnapshot();
+  }
+  // --- Registry ---
+  async fetchRegistry() {
+    try {
+      log2.info("Fetching agent registry from CDN...");
+      const response = await fetch(REGISTRY_URL);
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const data = await response.json();
+      this.registryAgents = data.agents ?? [];
+      const cache = {
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ttlHours: DEFAULT_TTL_HOURS,
+        data
+      };
+      fs2.mkdirSync(path2.dirname(CACHE_PATH), { recursive: true });
+      fs2.writeFileSync(CACHE_PATH, JSON.stringify(cache, null, 2));
+      log2.info({ count: this.registryAgents.length }, "Registry updated");
+    } catch (err) {
+      log2.warn({ err }, "Failed to fetch registry, using cached data");
+    }
+  }
+  async refreshRegistryIfStale() {
+    if (this.isCacheStale()) {
+      await this.fetchRegistry();
+    }
+  }
+  getRegistryAgents() {
+    return this.registryAgents;
+  }
+  getRegistryAgent(registryId) {
+    return this.registryAgents.find((a) => a.id === registryId);
+  }
+  findRegistryAgent(keyOrId) {
+    const byId = this.registryAgents.find((a) => a.id === keyOrId);
+    if (byId) return byId;
+    return this.registryAgents.find((a) => getAgentAlias(a.id) === keyOrId);
+  }
+  // --- Installed ---
+  getInstalled() {
+    return Object.values(this.store.getInstalled());
+  }
+  getInstalledEntries() {
+    return this.store.getInstalled();
+  }
+  getInstalledAgent(key) {
+    return this.store.getAgent(key);
+  }
+  // --- Discovery ---
+  getAvailable() {
+    const installed = this.store.getInstalled();
+    const items = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const [key, agent] of Object.entries(installed)) {
+      seenKeys.add(key);
+      const availability = agent.registryId ? checkDependencies(agent.registryId) : { available: true };
+      const registryEntry = agent.registryId ? this.registryAgents.find((a) => a.id === agent.registryId) : void 0;
+      items.push({
+        key,
+        registryId: agent.registryId ?? key,
+        name: agent.name,
+        version: agent.version,
+        description: registryEntry?.description,
+        distribution: agent.distribution,
+        installed: true,
+        available: availability.available,
+        missingDeps: availability.missing?.map((m) => m.label)
+      });
+    }
+    for (const agent of this.registryAgents) {
+      const alias = getAgentAlias(agent.id);
+      if (seenKeys.has(alias)) continue;
+      seenKeys.add(alias);
+      const dist = resolveDistribution(agent);
+      const availability = checkDependencies(agent.id);
+      items.push({
+        key: alias,
+        registryId: agent.id,
+        name: agent.name,
+        version: agent.version,
+        description: agent.description,
+        distribution: dist?.type ?? "binary",
+        installed: false,
+        available: dist !== null && availability.available,
+        missingDeps: availability.missing?.map((m) => m.label)
+      });
+    }
+    return items;
+  }
+  checkAvailability(keyOrId) {
+    const agent = this.findRegistryAgent(keyOrId);
+    if (!agent) return { available: false, reason: "Not found in the agent registry." };
+    const dist = resolveDistribution(agent);
+    if (!dist) {
+      return { available: false, reason: `Not available for your system. Check ${agent.website ?? agent.repository ?? "their website"} for other options.` };
+    }
+    return checkDependencies(agent.id);
+  }
+  // --- Install/Uninstall ---
+  async install(keyOrId, progress, force) {
+    const agent = this.findRegistryAgent(keyOrId);
+    if (!agent) {
+      const msg = `"${keyOrId}" was not found in the agent registry. Run "openacp agents" to see what's available.`;
+      await progress?.onError(msg);
+      return { ok: false, agentKey: keyOrId, error: msg };
+    }
+    const agentKey = getAgentAlias(agent.id);
+    if (this.store.hasAgent(agentKey) && !force) {
+      const existing = this.store.getAgent(agentKey);
+      const msg = `${agent.name} is already installed (v${existing.version}). Use --force to reinstall.`;
+      await progress?.onError(msg);
+      return { ok: false, agentKey, error: msg };
+    }
+    return installAgent(agent, this.store, progress);
+  }
+  async uninstall(key) {
+    if (!this.store.hasAgent(key)) {
+      return { ok: false, error: `"${key}" is not installed.` };
+    }
+    await uninstallAgent(key, this.store);
+    return { ok: true };
+  }
+  // --- Resolution (for AgentManager) ---
+  resolve(key) {
+    const agent = this.store.getAgent(key);
+    if (!agent) return void 0;
+    return {
+      name: key,
+      command: agent.command,
+      args: agent.args,
+      workingDirectory: agent.workingDirectory,
+      env: agent.env
+    };
+  }
+  // --- Internal ---
+  isCacheStale() {
+    if (!fs2.existsSync(CACHE_PATH)) return true;
+    try {
+      const raw = JSON.parse(fs2.readFileSync(CACHE_PATH, "utf-8"));
+      const fetchedAt = new Date(raw.fetchedAt).getTime();
+      const ttlMs = (raw.ttlHours ?? DEFAULT_TTL_HOURS) * 60 * 60 * 1e3;
+      return Date.now() - fetchedAt > ttlMs;
+    } catch {
+      return true;
+    }
+  }
+  loadRegistryFromCacheOrSnapshot() {
+    if (fs2.existsSync(CACHE_PATH)) {
+      try {
+        const raw = JSON.parse(fs2.readFileSync(CACHE_PATH, "utf-8"));
+        if (raw.data?.agents) {
+          this.registryAgents = raw.data.agents;
+          log2.debug({ count: this.registryAgents.length }, "Loaded registry from cache");
+          return;
+        }
+      } catch {
+        log2.warn("Failed to load registry cache");
+      }
+    }
+    try {
+      const candidates = [
+        path2.join(import.meta.dirname, "data", "registry-snapshot.json"),
+        path2.join(import.meta.dirname, "..", "data", "registry-snapshot.json"),
+        path2.join(import.meta.dirname, "..", "..", "data", "registry-snapshot.json")
+      ];
+      for (const candidate of candidates) {
+        if (fs2.existsSync(candidate)) {
+          const raw = JSON.parse(fs2.readFileSync(candidate, "utf-8"));
+          this.registryAgents = raw.agents ?? [];
+          log2.debug({ count: this.registryAgents.length }, "Loaded registry from bundled snapshot");
+          return;
+        }
+      }
+      log2.warn("No registry data available (no cache, no snapshot)");
+    } catch {
+      log2.warn("Failed to load bundled registry snapshot");
+    }
+  }
+};
+
+export {
+  AgentCatalog
+};
+//# sourceMappingURL=chunk-5MH66WUY.js.map