@openacp/cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,326 @@
+import { Readable, Writable } from 'node:stream';
+import { z } from 'zod';
+import { PromptResponse } from '@agentclientprotocol/sdk';
+
+interface IncomingMessage {
+    channelId: string;
+    threadId: string;
+    userId: string;
+    text: string;
+}
+interface OutgoingMessage {
+    type: 'text' | 'thought' | 'tool_call' | 'tool_update' | 'plan' | 'usage' | 'session_end' | 'error';
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+interface PermissionRequest {
+    id: string;
+    description: string;
+    options: PermissionOption[];
+}
+interface PermissionOption {
+    id: string;
+    label: string;
+    isAllow: boolean;
+}
+interface NotificationMessage {
+    sessionId: string;
+    sessionName?: string;
+    type: 'completed' | 'error' | 'permission' | 'input_required';
+    summary: string;
+    deepLink?: string;
+}
+type AgentEvent = {
+    type: 'text';
+    content: string;
+} | {
+    type: 'thought';
+    content: string;
+} | {
+    type: 'tool_call';
+    id: string;
+    name: string;
+    kind?: string;
+    status: string;
+    content?: unknown;
+    locations?: unknown;
+} | {
+    type: 'tool_update';
+    id: string;
+    status: string;
+    content?: unknown;
+    locations?: unknown;
+} | {
+    type: 'plan';
+    entries: PlanEntry[];
+} | {
+    type: 'usage';
+    tokensUsed?: number;
+    contextSize?: number;
+    cost?: {
+        amount: number;
+        currency: string;
+    };
+} | {
+    type: 'commands_update';
+    commands: unknown[];
+} | {
+    type: 'session_end';
+    reason: string;
+} | {
+    type: 'error';
+    message: string;
+};
+interface PlanEntry {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    priority: 'high' | 'medium' | 'low';
+}
+interface AgentDefinition {
+    name: string;
+    command: string;
+    args: string[];
+    workingDirectory?: string;
+    env?: Record<string, string>;
+}
+type SessionStatus = 'initializing' | 'active' | 'cancelled' | 'finished' | 'error';
+
+declare const log: {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+
+interface ChannelConfig {
+    enabled: boolean;
+    [key: string]: unknown;
+}
+declare abstract class ChannelAdapter {
+    protected core: any;
+    protected config: ChannelConfig;
+    constructor(core: any, config: ChannelConfig);
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    abstract sendMessage(sessionId: string, content: OutgoingMessage): Promise<void>;
+    abstract sendPermissionRequest(sessionId: string, request: PermissionRequest): Promise<void>;
+    abstract sendNotification(notification: NotificationMessage): Promise<void>;
+    abstract createSessionThread(sessionId: string, name: string): Promise<string>;
+    abstract renameSessionThread(sessionId: string, newName: string): Promise<void>;
+}
+
+declare class NotificationManager {
+    private adapters;
+    constructor(adapters: Map<string, ChannelAdapter>);
+    notify(channelId: string, notification: NotificationMessage): Promise<void>;
+    notifyAll(notification: NotificationMessage): Promise<void>;
+}
+
+declare function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array>;
+declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
+
+declare class StderrCapture {
+    private maxLines;
+    private lines;
+    constructor(maxLines?: number);
+    append(chunk: string): void;
+    getLastLines(): string;
+}
+
+declare const PLUGINS_DIR: string;
+declare const ConfigSchema: z.ZodObject<{
+    channels: z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        workingDirectory: z.ZodOptional<z.ZodString>;
+        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        workingDirectory?: string | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        env?: Record<string, string> | undefined;
+    }>>;
+    defaultAgent: z.ZodString;
+    workspace: z.ZodDefault<z.ZodObject<{
+        baseDir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        baseDir: string;
+    }, {
+        baseDir?: string | undefined;
+    }>>;
+    security: z.ZodDefault<z.ZodObject<{
+        allowedUserIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        maxConcurrentSessions: z.ZodDefault<z.ZodNumber>;
+        sessionTimeoutMinutes: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allowedUserIds: string[];
+        maxConcurrentSessions: number;
+        sessionTimeoutMinutes: number;
+    }, {
+        allowedUserIds?: string[] | undefined;
+        maxConcurrentSessions?: number | undefined;
+        sessionTimeoutMinutes?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    channels: Record<string, z.objectOutputType<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    agents: Record<string, {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        workingDirectory?: string | undefined;
+    }>;
+    defaultAgent: string;
+    workspace: {
+        baseDir: string;
+    };
+    security: {
+        allowedUserIds: string[];
+        maxConcurrentSessions: number;
+        sessionTimeoutMinutes: number;
+    };
+}, {
+    channels: Record<string, z.objectInputType<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+    agents: Record<string, {
+        command: string;
+        args?: string[] | undefined;
+        workingDirectory?: string | undefined;
+        env?: Record<string, string> | undefined;
+    }>;
+    defaultAgent: string;
+    workspace?: {
+        baseDir?: string | undefined;
+    } | undefined;
+    security?: {
+        allowedUserIds?: string[] | undefined;
+        maxConcurrentSessions?: number | undefined;
+        sessionTimeoutMinutes?: number | undefined;
+    } | undefined;
+}>;
+type Config = z.infer<typeof ConfigSchema>;
+declare function expandHome(p: string): string;
+declare class ConfigManager {
+    private config;
+    private configPath;
+    constructor();
+    load(): Promise<void>;
+    get(): Config;
+    save(updates: Record<string, unknown>): Promise<void>;
+    resolveWorkspace(input?: string): string;
+    private applyEnvOverrides;
+    private deepMerge;
+}
+
+declare class AgentInstance {
+    private connection;
+    private child;
+    private stderrCapture;
+    private terminals;
+    sessionId: string;
+    agentName: string;
+    onSessionUpdate: (event: AgentEvent) => void;
+    onPermissionRequest: (request: PermissionRequest) => Promise<string>;
+    private constructor();
+    static spawn(agentDef: AgentDefinition, workingDirectory: string): Promise<AgentInstance>;
+    private createClient;
+    prompt(text: string): Promise<PromptResponse>;
+    cancel(): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+declare class AgentManager {
+    private config;
+    constructor(config: Config);
+    getAvailableAgents(): AgentDefinition[];
+    getAgent(name: string): AgentDefinition | undefined;
+    spawn(agentName: string, workingDirectory: string): Promise<AgentInstance>;
+}
+
+declare class Session {
+    id: string;
+    channelId: string;
+    threadId: string;
+    agentName: string;
+    workingDirectory: string;
+    agentInstance: AgentInstance;
+    status: SessionStatus;
+    name?: string;
+    promptQueue: string[];
+    promptRunning: boolean;
+    createdAt: Date;
+    adapter?: ChannelAdapter;
+    pendingPermission?: {
+        requestId: string;
+        resolve: (optionId: string) => void;
+    };
+    constructor(opts: {
+        id?: string;
+        channelId: string;
+        agentName: string;
+        workingDirectory: string;
+        agentInstance: AgentInstance;
+    });
+    enqueuePrompt(text: string): Promise<void>;
+    private runPrompt;
+    private autoName;
+    cancel(): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+declare class SessionManager {
+    private sessions;
+    createSession(channelId: string, agentName: string, workingDirectory: string, agentManager: AgentManager): Promise<Session>;
+    getSession(sessionId: string): Session | undefined;
+    getSessionByThread(channelId: string, threadId: string): Session | undefined;
+    cancelSession(sessionId: string): Promise<void>;
+    listSessions(channelId?: string): Session[];
+    destroyAll(): Promise<void>;
+}
+
+declare class OpenACPCore {
+    configManager: ConfigManager;
+    agentManager: AgentManager;
+    sessionManager: SessionManager;
+    notificationManager: NotificationManager;
+    adapters: Map<string, ChannelAdapter>;
+    constructor(configManager: ConfigManager);
+    registerAdapter(name: string, adapter: ChannelAdapter): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleMessage(message: IncomingMessage): Promise<void>;
+    handleNewSession(channelId: string, agentName?: string, workspacePath?: string): Promise<Session>;
+    handleNewChat(channelId: string, currentThreadId: string): Promise<Session | null>;
+    private toOutgoingMessage;
+    wireSessionEvents(session: Session, adapter: ChannelAdapter): void;
+}
+
+interface AdapterFactory {
+    name: string;
+    createAdapter(core: any, config: any): ChannelAdapter;
+}
+declare function installPlugin(packageName: string): void;
+declare function uninstallPlugin(packageName: string): void;
+declare function listPlugins(): Record<string, string>;
+declare function loadAdapterFactory(packageName: string): Promise<AdapterFactory | null>;
+
+export { type AdapterFactory, type AgentDefinition, type AgentEvent, AgentInstance, AgentManager, ChannelAdapter, type ChannelConfig, type Config, ConfigManager, type IncomingMessage, NotificationManager, type NotificationMessage, OpenACPCore, type OutgoingMessage, PLUGINS_DIR, type PermissionOption, type PermissionRequest, type PlanEntry, Session, SessionManager, type SessionStatus, StderrCapture, expandHome, installPlugin, listPlugins, loadAdapterFactory, log, nodeToWebReadable, nodeToWebWritable, uninstallPlugin };

package/dist/index.js

@@ -0,0 +1,50 @@
+import {
+  AgentInstance,
+  AgentManager,
+  NotificationManager,
+  OpenACPCore,
+  Session,
+  SessionManager,
+  StderrCapture,
+  nodeToWebReadable,
+  nodeToWebWritable
+} from "./chunk-624B5RFL.js";
+import {
+  ConfigManager,
+  PLUGINS_DIR,
+  expandHome,
+  installPlugin,
+  listPlugins,
+  loadAdapterFactory,
+  log,
+  uninstallPlugin
+} from "./chunk-FLAM2AON.js";
+
+// packages/core/src/channel.ts
+var ChannelAdapter = class {
+  constructor(core, config) {
+    this.core = core;
+    this.config = config;
+  }
+};
+export {
+  AgentInstance,
+  AgentManager,
+  ChannelAdapter,
+  ConfigManager,
+  NotificationManager,
+  OpenACPCore,
+  PLUGINS_DIR,
+  Session,
+  SessionManager,
+  StderrCapture,
+  expandHome,
+  installPlugin,
+  listPlugins,
+  loadAdapterFactory,
+  log,
+  nodeToWebReadable,
+  nodeToWebWritable,
+  uninstallPlugin
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../packages/core/src/channel.ts"],"sourcesContent":["import type { OutgoingMessage, PermissionRequest, NotificationMessage } from './types.js'\n\nexport interface ChannelConfig {\n  enabled: boolean\n  [key: string]: unknown\n}\n\nexport abstract class ChannelAdapter {\n  constructor(protected core: any, protected config: ChannelConfig) {}\n\n  abstract start(): Promise<void>\n  abstract stop(): Promise<void>\n\n  // Outgoing: core → channel\n  abstract sendMessage(sessionId: string, content: OutgoingMessage): Promise<void>\n  abstract sendPermissionRequest(sessionId: string, request: PermissionRequest): Promise<void>\n  abstract sendNotification(notification: NotificationMessage): Promise<void>\n\n  // Session lifecycle on channel side\n  abstract createSessionThread(sessionId: string, name: string): Promise<string>  // returns threadId\n  abstract renameSessionThread(sessionId: string, newName: string): Promise<void>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAOO,IAAe,iBAAf,MAA8B;AAAA,EACnC,YAAsB,MAAqB,QAAuB;AAA5C;AAAqB;AAAA,EAAwB;AAarE;","names":[]}

package/dist/main-2DVA2NVU.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  OpenACPCore
+} from "./chunk-624B5RFL.js";
+import {
+  ConfigManager,
+  loadAdapterFactory,
+  log
+} from "./chunk-FLAM2AON.js";
+
+// packages/core/src/main.ts
+var shuttingDown = false;
+async function startServer() {
+  const configManager = new ConfigManager();
+  await configManager.load();
+  const config = configManager.get();
+  log.info("Config loaded from", configManager["configPath"]);
+  const core = new OpenACPCore(configManager);
+  for (const [channelName, channelConfig] of Object.entries(config.channels)) {
+    if (!channelConfig.enabled) continue;
+    if (channelName === "telegram") {
+      let TelegramAdapter;
+      try {
+        const mod = await import("@openacp/adapter-telegram");
+        TelegramAdapter = mod.TelegramAdapter;
+      } catch {
+        const adapterPath = new URL("../../adapters/telegram/dist/index.js", import.meta.url).pathname;
+        const mod = await import(adapterPath);
+        TelegramAdapter = mod.TelegramAdapter;
+      }
+      core.registerAdapter("telegram", new TelegramAdapter(core, channelConfig));
+      log.info("Telegram adapter registered (built-in)");
+    } else if (channelConfig.adapter) {
+      const factory = await loadAdapterFactory(channelConfig.adapter);
+      if (factory) {
+        const adapter = factory.createAdapter(core, channelConfig);
+        core.registerAdapter(channelName, adapter);
+        log.info(`${channelName} adapter registered (plugin: ${channelConfig.adapter})`);
+      } else {
+        log.error(`Skipping channel "${channelName}" \u2014 adapter "${channelConfig.adapter}" failed to load`);
+      }
+    } else {
+      log.error(`Channel "${channelName}" has no built-in adapter. Set "adapter" field to a plugin package.`);
+    }
+  }
+  if (core.adapters.size === 0) {
+    log.error("No channels enabled. Enable at least one channel in config.");
+    process.exit(1);
+  }
+  await core.start();
+  const agents = Object.keys(config.agents).join(", ");
+  log.info(`OpenACP started. Agents: ${agents}`);
+  log.info("Press Ctrl+C to stop.");
+  const shutdown = async (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log.info(`${signal} received. Shutting down...`);
+    try {
+      await core.stop();
+    } catch (err) {
+      log.error("Error during shutdown:", err);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("uncaughtException", (err) => {
+    log.error("Uncaught exception:", err);
+  });
+  process.on("unhandledRejection", (err) => {
+    log.error("Unhandled rejection:", err);
+  });
+}
+var isDirectExecution = process.argv[1]?.endsWith("main.js");
+if (isDirectExecution) {
+  startServer().catch((err) => {
+    log.error("Fatal:", err);
+    process.exit(1);
+  });
+}
+export {
+  startServer
+};
+//# sourceMappingURL=main-2DVA2NVU.js.map

package/dist/main-2DVA2NVU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../packages/core/src/main.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { ConfigManager } from './config.js'\nimport { OpenACPCore } from './core.js'\nimport { loadAdapterFactory } from './plugin-manager.js'\nimport { log } from './log.js'\n\nlet shuttingDown = false\n\nexport async function startServer() {\n  // 1. Load config\n  const configManager = new ConfigManager()\n  await configManager.load()\n\n  const config = configManager.get()\n  log.info('Config loaded from', configManager['configPath'])\n\n  // 2. Create core\n  const core = new OpenACPCore(configManager)\n\n  // 3. Register adapters from config\n  for (const [channelName, channelConfig] of Object.entries(config.channels)) {\n    if (!channelConfig.enabled) continue\n\n    if (channelName === 'telegram') {\n      // Built-in adapter — try bundled import first, fall back to relative path for dev\n      let TelegramAdapter: any\n      try {\n        // @ts-ignore — optional peer dependency, may not be installed\n        const mod = await import('@openacp/adapter-telegram')\n        TelegramAdapter = mod.TelegramAdapter\n      } catch {\n        // Dev mode: resolve from workspace via relative path\n        const adapterPath = new URL('../../adapters/telegram/dist/index.js', import.meta.url).pathname\n        const mod = await import(adapterPath)\n        TelegramAdapter = mod.TelegramAdapter\n      }\n      core.registerAdapter('telegram', new TelegramAdapter(core, channelConfig))\n      log.info('Telegram adapter registered (built-in)')\n    } else if (channelConfig.adapter) {\n      // Plugin adapter\n      const factory = await loadAdapterFactory(channelConfig.adapter)\n      if (factory) {\n        const adapter = factory.createAdapter(core, channelConfig)\n        core.registerAdapter(channelName, adapter)\n        log.info(`${channelName} adapter registered (plugin: ${channelConfig.adapter})`)\n      } else {\n        log.error(`Skipping channel \"${channelName}\" — adapter \"${channelConfig.adapter}\" failed to load`)\n      }\n    } else {\n      log.error(`Channel \"${channelName}\" has no built-in adapter. Set \"adapter\" field to a plugin package.`)\n    }\n  }\n\n  if (core.adapters.size === 0) {\n    log.error('No channels enabled. Enable at least one channel in config.')\n    process.exit(1)\n  }\n\n  // 4. Start\n  await core.start()\n\n  // 5. Log ready\n  const agents = Object.keys(config.agents).join(', ')\n  log.info(`OpenACP started. Agents: ${agents}`)\n  log.info('Press Ctrl+C to stop.')\n\n  // 6. Graceful shutdown\n  const shutdown = async (signal: string) => {\n    if (shuttingDown) return\n    shuttingDown = true\n    log.info(`${signal} received. Shutting down...`)\n\n    try {\n      await core.stop()\n    } catch (err) {\n      log.error('Error during shutdown:', err)\n    }\n\n    process.exit(0)\n  }\n\n  process.on('SIGINT', () => shutdown('SIGINT'))\n  process.on('SIGTERM', () => shutdown('SIGTERM'))\n\n  process.on('uncaughtException', (err) => {\n    log.error('Uncaught exception:', err)\n  })\n\n  process.on('unhandledRejection', (err) => {\n    log.error('Unhandled rejection:', err)\n  })\n}\n\n// Direct execution for dev (node packages/core/dist/main.js)\nconst isDirectExecution = process.argv[1]?.endsWith('main.js')\nif (isDirectExecution) {\n  startServer().catch((err) => {\n    log.error('Fatal:', err)\n    process.exit(1)\n  })\n}\n"],"mappings":";;;;;;;;;;;AAOA,IAAI,eAAe;AAEnB,eAAsB,cAAc;AAElC,QAAM,gBAAgB,IAAI,cAAc;AACxC,QAAM,cAAc,KAAK;AAEzB,QAAM,SAAS,cAAc,IAAI;AACjC,MAAI,KAAK,sBAAsB,cAAc,YAAY,CAAC;AAG1D,QAAM,OAAO,IAAI,YAAY,aAAa;AAG1C,aAAW,CAAC,aAAa,aAAa,KAAK,OAAO,QAAQ,OAAO,QAAQ,GAAG;AAC1E,QAAI,CAAC,cAAc,QAAS;AAE5B,QAAI,gBAAgB,YAAY;AAE9B,UAAI;AACJ,UAAI;AAEF,cAAM,MAAM,MAAM,OAAO,2BAA2B;AACpD,0BAAkB,IAAI;AAAA,MACxB,QAAQ;AAEN,cAAM,cAAc,IAAI,IAAI,yCAAyC,YAAY,GAAG,EAAE;AACtF,cAAM,MAAM,MAAM,OAAO;AACzB,0BAAkB,IAAI;AAAA,MACxB;AACA,WAAK,gBAAgB,YAAY,IAAI,gBAAgB,MAAM,aAAa,CAAC;AACzE,UAAI,KAAK,wCAAwC;AAAA,IACnD,WAAW,cAAc,SAAS;AAEhC,YAAM,UAAU,MAAM,mBAAmB,cAAc,OAAO;AAC9D,UAAI,SAAS;AACX,cAAM,UAAU,QAAQ,cAAc,MAAM,aAAa;AACzD,aAAK,gBAAgB,aAAa,OAAO;AACzC,YAAI,KAAK,GAAG,WAAW,gCAAgC,cAAc,OAAO,GAAG;AAAA,MACjF,OAAO;AACL,YAAI,MAAM,qBAAqB,WAAW,qBAAgB,cAAc,OAAO,kBAAkB;AAAA,MACnG;AAAA,IACF,OAAO;AACL,UAAI,MAAM,YAAY,WAAW,qEAAqE;AAAA,IACxG;AAAA,EACF;AAEA,MAAI,KAAK,SAAS,SAAS,GAAG;AAC5B,QAAI,MAAM,6DAA6D;AACvE,YAAQ,KAAK,CAAC;AAAA,EAChB;AAGA,QAAM,KAAK,MAAM;AAGjB,QAAM,SAAS,OAAO,KAAK,OAAO,MAAM,EAAE,KAAK,IAAI;AACnD,MAAI,KAAK,4BAA4B,MAAM,EAAE;AAC7C,MAAI,KAAK,uBAAuB;AAGhC,QAAM,WAAW,OAAO,WAAmB;AACzC,QAAI,aAAc;AAClB,mBAAe;AACf,QAAI,KAAK,GAAG,MAAM,6BAA6B;AAE/C,QAAI;AACF,YAAM,KAAK,KAAK;AAAA,IAClB,SAAS,KAAK;AACZ,UAAI,MAAM,0BAA0B,GAAG;AAAA,IACzC;AAEA,YAAQ,KAAK,CAAC;AAAA,EAChB;AAEA,UAAQ,GAAG,UAAU,MAAM,SAAS,QAAQ,CAAC;AAC7C,UAAQ,GAAG,WAAW,MAAM,SAAS,SAAS,CAAC;AAE/C,UAAQ,GAAG,qBAAqB,CAAC,QAAQ;AACvC,QAAI,MAAM,uBAAuB,GAAG;AAAA,EACtC,CAAC;AAED,UAAQ,GAAG,sBAAsB,CAAC,QAAQ;AACxC,QAAI,MAAM,wBAAwB,GAAG;AAAA,EACvC,CAAC;AACH;AAGA,IAAM,oBAAoB,QAAQ,KAAK,CAAC,GAAG,SAAS,SAAS;AAC7D,IAAI,mBAAmB;AACrB,cAAY,EAAE,MAAM,CAAC,QAAQ;AAC3B,QAAI,MAAM,UAAU,GAAG;AACvB,YAAQ,KAAK,CAAC;AAAA,EAChB,CAAC;AACH;","names":[]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@openacp/cli",
+  "version": "0.1.0",
+  "description": "Self-hosted bridge for AI coding agents via ACP protocol",
+  "type": "module",
+  "bin": {
+    "openacp": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.16.0",
+    "nanoid": "^5.0.0",
+    "zod": "^3.25.0",
+    "grammy": "^1.30.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicepkg/OpenACP"
+  },
+  "license": "AGPL-3.0",
+  "keywords": [
+    "acp",
+    "ai",
+    "coding-agent",
+    "telegram",
+    "claude",
+    "codex"
+  ]
+}