agent-gear 1.0.0

package/src/acp/bridge.ts

@@ -0,0 +1,327 @@
+import * as acp from '@agentclientprotocol/sdk';
+import { EventEmitter } from 'events';
+import type { Socket } from 'socket.io-client';
+import { AcpSpawner } from './spawner.js';
+
+const ACP_PROTOCOL_VERSION = 1;
+
+export interface AcpBridgeOptions {
+  sessionId: string;
+  cwd: string;
+  mcpServers?: Array<{ name: string; command: string; args?: string[]; env?: Array<{ name: string; value: string }> }>;
+}
+
+interface QueuedInput {
+  type: string;
+  content: string;
+}
+
+function toMcpServers(servers: AcpBridgeOptions['mcpServers']): acp.McpServer[] {
+  return (servers ?? []).map((s) => ({
+    name: s.name,
+    command: s.command,
+    args: s.args ?? [],
+    env: s.env ?? [],
+  }));
+}
+
+export class AcpSessionBridge extends EventEmitter implements acp.Client {
+  private spawner: AcpSpawner;
+  private socket: Socket;
+  private sessionId: string;
+  private cwd: string;
+  private mcpServers: AcpBridgeOptions['mcpServers'];
+  private connection: acp.ClientSideConnection | null = null;
+  private acpSessionId: string | null = null;
+  private activePrompt: Promise<acp.PromptResponse> | null = null;
+  private inputQueue: QueuedInput[] = [];
+  private textChunkBuffer = '';
+  private textChunkTimer: ReturnType<typeof setTimeout> | null = null;
+  private initializing = false;
+
+  constructor(socket: Socket, options: AcpBridgeOptions, spawner?: AcpSpawner) {
+    super();
+    this.socket = socket;
+    this.sessionId = options.sessionId;
+    this.cwd = options.cwd;
+    this.mcpServers = options.mcpServers;
+    this.spawner = spawner ?? new AcpSpawner({ sessionId: options.sessionId, cwd: options.cwd });
+  }
+
+  async start(): Promise<void> {
+    if (this.initializing) return;
+    this.initializing = true;
+
+    this.spawner.start();
+    try {
+      await this.initConnection();
+      const result = await this.connection!.newSession({
+        cwd: this.cwd,
+        mcpServers: toMcpServers(this.mcpServers),
+      });
+      this.acpSessionId = result.sessionId;
+      this.initializing = false;
+
+      this.emit('acp:initialized', {
+        sessionId: this.sessionId,
+        acpSessionId: this.acpSessionId,
+        modes: this.extractModes(result.modes),
+        currentModeId: result.modes?.currentModeId ?? null,
+        currentModel: this.extractCurrentModel(result.models),
+        availableModels: this.extractAvailableModels(result.models),
+        currentModelId: result.models?.currentModelId ?? null,
+      });
+
+      this.flushInputQueue();
+    } catch (error) {
+      this.initializing = false;
+      this.handleError(error);
+    }
+  }
+
+  async resume(externalSessionId: string): Promise<void> {
+    if (this.initializing) return;
+    this.initializing = true;
+
+    this.spawner.start();
+    try {
+      await this.initConnection();
+      const result = await this.connection!.resumeSession({
+        sessionId: externalSessionId,
+        cwd: this.cwd,
+      });
+      this.acpSessionId = externalSessionId;
+      this.initializing = false;
+
+      this.emit('acp:initialized', {
+        sessionId: this.sessionId,
+        acpSessionId: this.acpSessionId,
+        modes: this.extractModes(result.modes),
+        currentModeId: result.modes?.currentModeId ?? null,
+        currentModel: this.extractCurrentModel(result.models),
+        availableModels: this.extractAvailableModels(result.models),
+        currentModelId: result.models?.currentModelId ?? null,
+      });
+    } catch (error) {
+      // resumeSession may fail if agent doesn't support session.resume
+      // fallback to newSession
+      try {
+        const result = await this.connection!.newSession({
+          cwd: this.cwd,
+          mcpServers: toMcpServers(this.mcpServers),
+        });
+        this.acpSessionId = result.sessionId;
+        this.initializing = false;
+
+        this.emit('acp:initialized', {
+          sessionId: this.sessionId,
+          acpSessionId: this.acpSessionId,
+          modes: this.extractModes(result.modes),
+          currentModeId: result.modes?.currentModeId ?? null,
+          currentModel: this.extractCurrentModel(result.models),
+        availableModels: this.extractAvailableModels(result.models),
+        currentModelId: result.models?.currentModelId ?? null,
+        });
+      } catch (fallbackError) {
+        this.initializing = false;
+        this.handleError(fallbackError);
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    try {
+      if (this.acpSessionId && this.connection) {
+        await this.connection.cancel({ sessionId: this.acpSessionId });
+        await this.connection.closeSession({ sessionId: this.acpSessionId });
+      }
+    } catch { /* ignore */ }
+    this.activePrompt = null;
+    this.inputQueue = [];
+    this.spawner.stop();
+    this.emitStopped('user_close');
+  }
+
+  cancel(): void {
+    if (this.acpSessionId && this.connection) {
+      this.connection.cancel({ sessionId: this.acpSessionId });
+    }
+  }
+
+  async setMode(modeId: string): Promise<void> {
+    if (!this.connection || !this.acpSessionId) return;
+    await this.connection.setSessionMode({
+      sessionId: this.acpSessionId,
+      modeId,
+    });
+  }
+
+  async setModel(modelId: string): Promise<void> {
+    if (!this.connection || !this.acpSessionId) return;
+    await this.connection.unstable_setSessionModel({
+      sessionId: this.acpSessionId,
+      modelId,
+    });
+  }
+
+  sendInput(message: { type: string; content: string }): void {
+    if (this.activePrompt) {
+      this.inputQueue.push(message);
+      return;
+    }
+    this.processPrompt(message);
+  }
+
+  private async processPrompt(message: QueuedInput): Promise<void> {
+    if (!this.connection || !this.acpSessionId) return;
+
+    this.activePrompt = this.connection.prompt({
+      sessionId: this.acpSessionId,
+      prompt: [{ type: 'text' as const, text: message.content }],
+    });
+
+    try {
+      await this.activePrompt;
+    } catch {
+      // cancelled or error
+    } finally {
+      this.activePrompt = null;
+      if (this.inputQueue.length > 0) {
+        this.processPrompt(this.inputQueue.shift()!);
+      }
+    }
+  }
+
+  private async initConnection(): Promise<void> {
+    const input = this.spawner.stdin;
+    const output = this.spawner.stdout;
+    const stream = acp.ndJsonStream(input, output);
+    this.connection = new acp.ClientSideConnection(() => this, stream);
+    await this.connection.initialize({
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {},
+      clientInfo: {
+        name: 'agent-gear',
+        version: '1.0.0',
+      },
+    });
+  }
+
+  private flushInputQueue(): void {
+    while (this.inputQueue.length > 0) {
+      this.processPrompt(this.inputQueue.shift()!);
+    }
+  }
+
+  private extractModes(modes: acp.SessionModeState | null | undefined): Array<{ id: string; name: string; description?: string }> | null {
+    if (!modes?.availableModes) return null;
+    return modes.availableModes.map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description ?? undefined,
+    }));
+  }
+
+  private extractCurrentModel(models: acp.SessionModelState | null | undefined): { id: string; name: string; provider?: string } | null {
+    if (!models?.availableModels || !models.currentModelId) return null;
+    const found = models.availableModels.find((m) => m.modelId === models.currentModelId);
+    if (!found) return null;
+    return { id: found.modelId, name: found.name };
+  }
+
+  private extractAvailableModels(models: acp.SessionModelState | null | undefined): Array<{ id: string; name: string; provider?: string }> | null {
+    if (!models?.availableModels) return null;
+    return models.availableModels.map((m) => ({
+      id: m.modelId,
+      name: m.name,
+    }));
+  }
+
+  // ── acp.Client implementation ──
+
+  async sessionUpdate(params: acp.SessionNotification): Promise<void> {
+    const update = params.update;
+    switch (update.sessionUpdate) {
+      case 'agent_message_chunk':
+        if (update.content.type === 'text') {
+          this.textChunkBuffer += update.content.text;
+          this.scheduleTextFlush();
+        }
+        break;
+      case 'tool_call':
+      case 'tool_call_update':
+      case 'plan':
+      case 'agent_thought_chunk':
+        this.flushTextBuffer();
+        this.sendUpdate(update);
+        break;
+      case 'user_message_chunk':
+        break;
+      default:
+        this.flushTextBuffer();
+        this.sendUpdate(update);
+        break;
+    }
+  }
+
+  async requestPermission(
+    params: acp.RequestPermissionRequest,
+  ): Promise<acp.RequestPermissionResponse> {
+    return {
+      outcome: {
+        outcome: 'selected',
+        optionId: params.options.find((o) => o.kind === 'allow_once')?.optionId ?? params.options[0]?.optionId ?? 'reject',
+      },
+    };
+  }
+
+  // ── text buffering ──
+
+  private scheduleTextFlush(): void {
+    if (this.textChunkTimer) clearTimeout(this.textChunkTimer);
+    this.textChunkTimer = setTimeout(() => this.flushTextBuffer(), 50);
+  }
+
+  private flushTextBuffer(): void {
+    if (this.textChunkTimer) {
+      clearTimeout(this.textChunkTimer);
+      this.textChunkTimer = null;
+    }
+    if (this.textChunkBuffer) {
+      this.sendUpdate({
+        sessionUpdate: 'agent_message_chunk' as const,
+        content: { type: 'text' as const, text: this.textChunkBuffer },
+      } as acp.SessionUpdate);
+      this.textChunkBuffer = '';
+    }
+  }
+
+  // ── socket forwarding ──
+
+  private sendUpdate(update: acp.SessionUpdate): void {
+    this.socket.emit('acp:message', {
+      sessionId: this.sessionId,
+      message: update,
+    });
+  }
+
+  private emitStopped(reason: string, exitCode?: number): void {
+    this.socket.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
+    this.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
+  }
+
+  private handleError(error: unknown): void {
+    const msg = error instanceof Error ? error.message : String(error);
+    this.socket.emit('acp:stopped', {
+      sessionId: this.sessionId,
+      reason: 'error',
+      error: msg,
+    });
+    this.emit('acp:stopped', {
+      sessionId: this.sessionId,
+      reason: 'error',
+      error: msg,
+    });
+    this.spawner.stop();
+  }
+}

package/src/acp/detector.ts

@@ -0,0 +1,40 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+interface AcpServerInfo {
+  type: string;
+  available: boolean;
+  version?: string;
+}
+
+export class AcpDetector {
+  async detect(): Promise<AcpServerInfo[]> {
+    const servers: AcpServerInfo[] = [];
+
+    // Detect OpenCode
+    const opencode = await this.detectOpenCode();
+    servers.push(opencode);
+
+    return servers;
+  }
+
+  private async detectOpenCode(): Promise<AcpServerInfo> {
+    try {
+      const { stdout } = await execAsync('opencode -v');
+      const version = this.parseVersion(stdout);
+      return { type: 'opencode', available: true, version };
+    } catch {
+      return { type: 'opencode', available: false };
+    }
+  }
+
+  private parseVersion(output: string): string {
+    // Try to extract version from output
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : 'unknown';
+  }
+}
+
+export const acpDetector = new AcpDetector();

package/src/acp/spawner.ts

@@ -0,0 +1,94 @@
+import { spawn, execFileSync, type ChildProcess } from 'child_process';
+import { Writable, Readable } from 'node:stream';
+import { existsSync, mkdirSync } from 'fs';
+
+export interface AcpProcessOptions {
+  sessionId: string;
+  cwd: string;
+  command?: string;
+  args?: string[];
+}
+
+export class AcpSpawner {
+  private process: ChildProcess | null = null;
+  private sessionId: string;
+  private cwd: string;
+  private command: string;
+  private args: string[];
+  private resolveClosed: (() => void) | null = null;
+  private _closed: Promise<void>;
+
+  constructor(options: AcpProcessOptions) {
+    this.sessionId = options.sessionId;
+    this.cwd = options.cwd;
+    this.command = options.command ?? 'opencode';
+    this.args = options.args ?? ['acp'];
+    this._closed = new Promise((resolve) => { this.resolveClosed = resolve; });
+  }
+
+  start(): void {
+    const cmd = this.resolveCommand();
+    console.log(`Starting ACP server ${cmd}`)
+    mkdirSync(this.cwd, { recursive: true });
+    this.process = spawn(cmd, this.args, {
+      cwd: this.cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    this.process.stderr?.on('data', (data: Buffer) => {
+      console.error(`ACP stderr: ${data.toString()}`);
+    });
+
+    this.process.on('exit', (code, signal) => {
+      console.log(`ACP process exited with code ${code} and signal ${signal}`);
+      this.process = null;
+      this.resolveClosed?.();
+    });
+
+    this.process.on('error', (error) => {
+      console.error('ACP process error:', error);
+    });
+  }
+
+  get stdin(): WritableStream {
+    if (!this.process?.stdin) throw new Error('ACP process not running');
+    return Writable.toWeb(this.process.stdin) as WritableStream;
+  }
+
+  get stdout(): ReadableStream<Uint8Array> {
+    if (!this.process?.stdout) throw new Error('ACP process not running');
+    return Readable.toWeb(this.process.stdout) as ReadableStream<Uint8Array>;
+  }
+
+  get closed(): Promise<void> {
+    return this._closed;
+  }
+
+  stop(): void {
+    if (this.process) {
+      this.process.kill('SIGTERM');
+      setTimeout(() => {
+        if (this.process) {
+          this.process.kill('SIGKILL');
+        }
+      }, 5000);
+    }
+  }
+
+  isRunning(): boolean {
+    return this.process !== null;
+  }
+
+  private resolveCommand(): string {
+    if (this.command.includes('/')) return this.command;
+    const candidates = [this.command, `/usr/bin/${this.command}`, `/usr/local/bin/${this.command}`];
+    for (const cmd of candidates) {
+      try {
+        const result = execFileSync('which', [cmd], { encoding: 'utf8', timeout: 1000 });
+        if (result.trim()) return result.trim();
+      } catch { /* try next */ }
+      if (existsSync(cmd)) return cmd;
+    }
+    return this.command;
+  }
+}

package/src/acp/sync-bridge.ts

@@ -0,0 +1,111 @@
+import * as acp from '@agentclientprotocol/sdk';
+import { AcpSpawner } from './spawner.js';
+
+const ACP_PROTOCOL_VERSION = 1;
+const CONNECT_TIMEOUT_MS = 30_000;
+const LOAD_SESSION_TIMEOUT_MS = 120_000;
+
+async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  message: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timerPromise = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), ms);
+  });
+  try {
+    return await Promise.race([promise, timerPromise]);
+  } finally {
+    clearTimeout(timer!);
+  }
+}
+
+export interface AcpSyncBridgeOptions {
+  cwd: string;
+}
+
+export class AcpSyncBridge implements acp.Client {
+  private spawner: AcpSpawner;
+  private connection: acp.ClientSideConnection | null = null;
+  private updates: acp.SessionNotification[] = [];
+
+  constructor(options: AcpSyncBridgeOptions, spawner?: AcpSpawner) {
+    this.spawner = spawner ?? new AcpSpawner({
+      sessionId: `sync_${Date.now()}`,
+      cwd: options.cwd,
+    });
+  }
+
+  async connect(timeoutMs: number = CONNECT_TIMEOUT_MS): Promise<void> {
+    this.spawner.start();
+    const stream = acp.ndJsonStream(this.spawner.stdin, this.spawner.stdout);
+    this.connection = new acp.ClientSideConnection(() => this, stream);
+
+    const exitPromise = this.spawner.closed.then(() => {
+      throw new Error('ACP process exited unexpectedly');
+    });
+    exitPromise.catch(() => {});
+
+    const initPromise = this.connection.initialize({
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: {},
+      clientInfo: { name: 'agent-gear', version: '1.0.0' },
+    });
+
+    await withTimeout(
+      Promise.race([initPromise, exitPromise]),
+      timeoutMs,
+      `ACP connect timed out after ${timeoutMs}ms`,
+    );
+  }
+
+  async listSessions(cwd: string): Promise<acp.ListSessionsResponse> {
+    return this.connection!.listSessions({ cwd });
+  }
+
+  async loadSession(
+    sessionId: string,
+    cwd: string,
+    timeoutMs: number = LOAD_SESSION_TIMEOUT_MS,
+  ): Promise<{
+    config: acp.LoadSessionResponse;
+    updates: acp.SessionNotification[];
+  }> {
+    this.updates = [];
+
+    const exitPromise = this.spawner.closed.then(() => {
+      throw new Error('ACP process exited unexpectedly');
+    });
+    exitPromise.catch(() => {});
+
+    const config = await withTimeout(
+      Promise.race([
+        this.connection!.loadSession({
+          cwd,
+          sessionId,
+          mcpServers: [],
+        }),
+        exitPromise,
+      ]),
+      timeoutMs,
+      `ACP load-session timed out after ${timeoutMs}ms`,
+    );
+    return { config, updates: [...this.updates] };
+  }
+
+  async disconnect(sessionId?: string): Promise<void> {
+    if (sessionId) {
+      await this.connection?.closeSession({ sessionId }).catch(() => {});
+    }
+    this.spawner.stop();
+  }
+
+  async sessionUpdate(params: acp.SessionNotification): Promise<void> {
+    this.updates.push(params);
+  }
+
+  async requestPermission(): Promise<acp.RequestPermissionResponse> {
+    return { outcome: { outcome: 'cancelled' } };
+  }
+}

package/src/config.ts

@@ -0,0 +1,75 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse, stringify } from 'smol-toml';
+
+const CONFIG_DIR = join(homedir(), '.zag');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.toml');
+
+export interface ConfigData {
+  key?: { value: string };
+  server?: { endpoint: string };
+  controller?: { name: string };
+}
+
+export function readConfig(): ConfigData {
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  const content = readFileSync(CONFIG_FILE, 'utf-8');
+  return parse(content) as ConfigData;
+}
+
+export function writeConfig(data: ConfigData): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, stringify(data), 'utf-8');
+}
+
+export function clearConfigKey(): void {
+  const config = readConfig();
+  delete config.key;
+  writeConfig(config);
+}
+
+export function getKeyFromConfig(): string | undefined {
+  const config = readConfig();
+  return config.key?.value;
+}
+
+export function getEndpointFromConfig(): string | undefined {
+  const config = readConfig();
+  return config.server?.endpoint;
+}
+
+export function getControllerNameFromConfig(): string | undefined {
+  const config = readConfig();
+  return config.controller?.name;
+}
+
+export function saveKeyToConfig(key: string): void {
+  const config = readConfig();
+  config.key = { value: key };
+  writeConfig(config);
+}
+
+export function saveEndpointToConfig(endpoint: string): void {
+  const config = readConfig();
+  config.server = { endpoint };
+  writeConfig(config);
+}
+
+export function resolveKey(cliKey?: string): string | undefined {
+  if (cliKey) return cliKey;
+  const envKey = process.env.ZAG_CONTROLLER_KEY;
+  if (envKey) return envKey;
+  return getKeyFromConfig();
+}
+
+export function resolveEndpoint(cliEndpoint?: string): string | undefined {
+  if (cliEndpoint) return cliEndpoint;
+  const envEndpoint = process.env.ZAG_SERVER_ENDPOINT;
+  if (envEndpoint) return envEndpoint;
+  return getEndpointFromConfig();
+}

package/src/daemon.ts

@@ -0,0 +1,33 @@
+import { writeFileSync, existsSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const PID_FILE = join(tmpdir(), 'agent-gear.pid');
+
+export function writePid(): void {
+  writeFileSync(PID_FILE, process.pid.toString(), 'utf-8');
+}
+
+export function readPid(): number | null {
+  if (!existsSync(PID_FILE)) return null;
+  const content = readFileSync(PID_FILE, 'utf-8').trim();
+  const pid = parseInt(content, 10);
+  return isNaN(pid) ? null : pid;
+}
+
+export function removePid(): void {
+  if (existsSync(PID_FILE)) {
+    unlinkSync(PID_FILE);
+  }
+}
+
+export function isRunning(): boolean {
+  const pid = readPid();
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}