cli-copilot-worker 0.1.0

package/src/core/types.ts

@@ -0,0 +1,211 @@
+export type ConversationStatus =
+  | 'idle'
+  | 'running'
+  | 'waiting_answer'
+  | 'failed'
+  | 'cancelled';
+
+export type JobStatus =
+  | 'running'
+  | 'waiting_answer'
+  | 'completed'
+  | 'failed'
+  | 'cancelled';
+
+export type JobKind = 'run' | 'send' | 'answer';
+
+export type TranscriptRole =
+  | 'user'
+  | 'assistant'
+  | 'tool_use'
+  | 'tool_result'
+  | 'question'
+  | 'answer'
+  | 'status'
+  | 'error';
+
+export type CopilotFailureCategory =
+  | 'auth'
+  | 'rate_limit'
+  | 'connection'
+  | 'transient'
+  | 'fatal';
+
+export interface CopilotFailureInfo {
+  category: CopilotFailureCategory;
+  retryable: boolean;
+  message: string;
+  sessionErrorType?: string | undefined;
+  sessionStatusCode?: number | undefined;
+}
+
+export interface JobAttemptRecord {
+  profileId: string;
+  profileConfigDir: string;
+  startedAt: string;
+  endedAt?: string | undefined;
+  outcome: 'running' | 'completed' | 'failed';
+  failureCategory?: CopilotFailureCategory | undefined;
+  failureMessage?: string | undefined;
+  sessionErrorType?: string | undefined;
+  sessionStatusCode?: number | undefined;
+}
+
+export interface PendingQuestion {
+  question: string;
+  choices?: string[] | undefined;
+  allowFreeform: boolean;
+  askedAt: string;
+  sessionId: string;
+}
+
+export interface ConversationRecord {
+  id: string;
+  sessionId: string;
+  workspaceId: string;
+  cwd: string;
+  model: string;
+  status: ConversationStatus;
+  createdAt: string;
+  updatedAt: string;
+  hasStarted: boolean;
+  nextEntryIndex: number;
+  lastJobId?: string | undefined;
+  pendingQuestion?: PendingQuestion | undefined;
+  profileId?: string | undefined;
+  profileConfigDir?: string | undefined;
+  lastError?: string | undefined;
+}
+
+export interface JobRecord {
+  id: string;
+  conversationId: string;
+  kind: JobKind;
+  status: JobStatus;
+  inputFilePath: string;
+  createdAt: string;
+  startedAt: string;
+  endedAt?: string | undefined;
+  error?: string | undefined;
+  pid?: number | undefined;
+  turnIndex: number;
+  startEntryIndex: number;
+  endEntryIndex?: number | undefined;
+  attempts: JobAttemptRecord[];
+}
+
+export interface TranscriptEntry {
+  index: number;
+  conversationId: string;
+  jobId?: string | undefined;
+  role: TranscriptRole;
+  content: string;
+  timestamp: string;
+  data?: Record<string, unknown> | undefined;
+}
+
+export interface PersistedProfileState {
+  id: string;
+  configDir: string;
+  cooldownUntil?: number | undefined;
+  failureCount: number;
+  lastFailureReason?: string | undefined;
+  lastFailureCategory?: CopilotFailureCategory | undefined;
+  lastFailureAt?: string | undefined;
+  lastSuccessAt?: string | undefined;
+}
+
+export interface StateFile {
+  version: 1;
+  conversations: ConversationRecord[];
+  jobs: JobRecord[];
+  profiles: PersistedProfileState[];
+}
+
+export interface CopilotProfile {
+  id: string;
+  configDir: string;
+  cooldownUntil?: number | undefined;
+  failureCount: number;
+  lastFailureReason?: string | undefined;
+  lastFailureCategory?: CopilotFailureCategory | undefined;
+  lastFailureAt?: string | undefined;
+  lastSuccessAt?: string | undefined;
+}
+
+export interface DaemonMeta {
+  pid: number;
+  socketPath: string;
+  token: string;
+  startedAt: string;
+}
+
+export interface RunRequest {
+  inputFilePath: string;
+  content: string;
+  cwd: string;
+  model?: string | undefined;
+  timeoutMs?: number | undefined;
+  async?: boolean | undefined;
+}
+
+export interface SendRequest {
+  conversationId: string;
+  inputFilePath: string;
+  content: string;
+  timeoutMs?: number | undefined;
+  async?: boolean | undefined;
+}
+
+export interface AnswerRequest {
+  conversationId: string;
+  inputFilePath: string;
+  content: string;
+}
+
+export interface ReadRequest {
+  conversationId: string;
+  from?: number | undefined;
+  to?: number | undefined;
+  after?: number | undefined;
+  before?: number | undefined;
+  tokens?: number | undefined;
+  detail?: 'standard' | 'verbose' | 'full' | 'meta' | undefined;
+}
+
+export interface JobWaitRequest {
+  jobId: string;
+  timeoutSeconds?: number | undefined;
+  intervalSeconds?: number | undefined;
+}
+
+export type DaemonCommand =
+  | 'ping'
+  | 'run'
+  | 'send'
+  | 'answer'
+  | 'read'
+  | 'list'
+  | 'info'
+  | 'job.list'
+  | 'job.status'
+  | 'job.wait'
+  | 'job.read'
+  | 'job.cancel'
+  | 'daemon.stop'
+  | 'daemon.status';
+
+export interface DaemonRequestEnvelope {
+  id: string;
+  token: string;
+  command: DaemonCommand;
+  args?: Record<string, unknown> | undefined;
+}
+
+export interface DaemonResponseEnvelope {
+  id: string;
+  type: 'event' | 'result' | 'error';
+  event?: string | undefined;
+  data?: Record<string, unknown> | undefined;
+  error?: string | undefined;
+}

package/src/daemon/client.ts

@@ -0,0 +1,137 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+import { buildDaemonToken, ensureStateRoot } from '../core/paths.js';
+import type { DaemonMeta, DaemonRequestEnvelope, DaemonResponseEnvelope } from '../core/types.js';
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function cliLaunchSpec(): { command: string; args: string[] } {
+  const compiledCliPath = fileURLToPath(new URL('../cli.js', import.meta.url));
+  if (existsSync(compiledCliPath)) {
+    return {
+      command: process.execPath,
+      args: ['--import', 'tsx', compiledCliPath, 'daemon-run'],
+    };
+  }
+
+  const sourceCliPath = fileURLToPath(new URL('../cli.ts', import.meta.url));
+  return {
+    command: process.execPath,
+    args: ['--import', 'tsx', sourceCliPath, 'daemon-run'],
+  };
+}
+
+async function readDaemonMeta(): Promise<DaemonMeta | null> {
+  const { daemonMetaPath } = ensureStateRoot();
+  if (!existsSync(daemonMetaPath)) {
+    return null;
+  }
+
+  try {
+    const raw = await readFile(daemonMetaPath, 'utf8');
+    return JSON.parse(raw) as DaemonMeta;
+  } catch {
+    return null;
+  }
+}
+
+async function canConnect(socketPath: string): Promise<boolean> {
+  return await new Promise((resolve) => {
+    const socket = net.createConnection(socketPath, () => {
+      socket.end();
+      resolve(true);
+    });
+    socket.on('error', () => resolve(false));
+  });
+}
+
+export async function ensureDaemonMeta(): Promise<DaemonMeta> {
+  const existing = await readDaemonMeta();
+  if (existing && await canConnect(existing.socketPath)) {
+    return existing;
+  }
+
+  const { socketPath } = ensureStateRoot();
+  const token = buildDaemonToken();
+  const launchSpec = cliLaunchSpec();
+  const child = spawn(launchSpec.command, launchSpec.args, {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      CLI_COPILOT_WORKER_DAEMON_SOCKET: socketPath,
+      CLI_COPILOT_WORKER_DAEMON_TOKEN: token,
+    },
+  });
+  child.unref();
+
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    const current = await readDaemonMeta();
+    if (current && await canConnect(current.socketPath)) {
+      return current;
+    }
+    await delay(100);
+  }
+
+  throw new Error('Timed out waiting for cli-copilot-worker daemon to start');
+}
+
+export async function sendDaemonRequest(
+  command: DaemonRequestEnvelope['command'],
+  args?: Record<string, unknown>,
+  options?: {
+    onEvent?: ((event: string, data: Record<string, unknown>) => void) | undefined;
+  },
+): Promise<Record<string, unknown>> {
+  const meta = await ensureDaemonMeta();
+  const request: DaemonRequestEnvelope = {
+    id: `${Date.now()}`,
+    token: meta.token,
+    command,
+    args,
+  };
+
+  return await new Promise<Record<string, unknown>>((resolve, reject) => {
+    let buffer = '';
+    const socket = net.createConnection(meta.socketPath);
+
+    socket.on('connect', () => {
+      socket.write(`${JSON.stringify(request)}\n`);
+    });
+
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      let newlineIndex = buffer.indexOf('\n');
+      while (newlineIndex >= 0) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          const envelope = JSON.parse(line) as DaemonResponseEnvelope;
+          if (envelope.type === 'event') {
+            options?.onEvent?.(envelope.event ?? 'event', envelope.data ?? {});
+          } else if (envelope.type === 'result') {
+            socket.end();
+            resolve(envelope.data ?? {});
+          } else {
+            socket.end();
+            reject(new Error(envelope.error ?? 'Unknown daemon error'));
+          }
+        }
+        newlineIndex = buffer.indexOf('\n');
+      }
+    });
+
+    socket.on('error', reject);
+  });
+}
+
+export async function daemonIsRunning(): Promise<boolean> {
+  const meta = await readDaemonMeta();
+  return Boolean(meta && await canConnect(meta.socketPath));
+}

package/src/daemon/server.ts

@@ -0,0 +1,167 @@
+import net from 'node:net';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+
+import { ensureStateRoot } from '../core/paths.js';
+import type { DaemonRequestEnvelope, DaemonResponseEnvelope } from '../core/types.js';
+import { CliCopilotWorkerService } from './service.js';
+
+function writeEnvelope(socket: net.Socket, envelope: DaemonResponseEnvelope): void {
+  socket.write(`${JSON.stringify(envelope)}\n`);
+}
+
+export async function runDaemonServer(): Promise<void> {
+  const socketPath = process.env.CLI_COPILOT_WORKER_DAEMON_SOCKET ?? ensureStateRoot().socketPath;
+  const token = process.env.CLI_COPILOT_WORKER_DAEMON_TOKEN;
+  if (!token) {
+    throw new Error('Missing CLI_COPILOT_WORKER_DAEMON_TOKEN');
+  }
+
+  if (existsSync(socketPath)) {
+    await unlink(socketPath).catch(() => {});
+  }
+
+  const service = new CliCopilotWorkerService();
+  await service.initialize();
+  await service.writeDaemonMeta(socketPath, token);
+
+  const shutdown = async () => {
+    await service.shutdown().catch(() => {});
+    server.close();
+    process.exit(0);
+  };
+
+  const server = net.createServer((socket) => {
+    let buffer = '';
+    socket.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      let newlineIndex = buffer.indexOf('\n');
+      while (newlineIndex >= 0) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line) {
+          void handleRequest(line, socket, token, service, shutdown);
+        }
+        newlineIndex = buffer.indexOf('\n');
+      }
+    });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(socketPath, () => resolve());
+  });
+
+  process.on('SIGINT', () => void shutdown());
+  process.on('SIGTERM', () => void shutdown());
+}
+
+async function handleRequest(
+  line: string,
+  socket: net.Socket,
+  token: string,
+  service: CliCopilotWorkerService,
+  shutdown: () => Promise<void>,
+): Promise<void> {
+  let envelope: DaemonRequestEnvelope;
+  try {
+    envelope = JSON.parse(line) as DaemonRequestEnvelope;
+  } catch {
+    writeEnvelope(socket, {
+      id: 'unknown',
+      type: 'error',
+      error: 'Invalid JSON request',
+    });
+    return;
+  }
+
+  if (envelope.token !== token) {
+    writeEnvelope(socket, {
+      id: envelope.id,
+      type: 'error',
+      error: 'Unauthorized',
+    });
+    return;
+  }
+
+  const writer = {
+    event(name: string, data: Record<string, unknown>) {
+      writeEnvelope(socket, {
+        id: envelope.id,
+        type: 'event',
+        event: name,
+        data,
+      });
+    },
+  };
+
+  try {
+    let result: Record<string, unknown>;
+    let shouldShutdown = false;
+    switch (envelope.command) {
+      case 'ping':
+        result = await service.ping();
+        break;
+      case 'run':
+        result = await service.run(envelope.args as never, writer);
+        break;
+      case 'send':
+        result = await service.send(envelope.args as never, writer);
+        break;
+      case 'answer':
+        result = await service.answer(envelope.args as never);
+        break;
+      case 'read':
+        result = await service.read(envelope.args as never);
+        break;
+      case 'list':
+        result = await service.list();
+        break;
+      case 'info':
+        result = await service.info(String((envelope.args ?? {}).conversationId));
+        break;
+      case 'job.list':
+        result = await service.jobList();
+        break;
+      case 'job.status':
+        result = await service.jobStatus(String((envelope.args ?? {}).jobId));
+        break;
+      case 'job.wait':
+        result = await service.jobWait(envelope.args as never);
+        break;
+      case 'job.read':
+        result = await service.jobRead(String((envelope.args ?? {}).jobId));
+        break;
+      case 'job.cancel':
+        result = await service.jobCancel(String((envelope.args ?? {}).jobId));
+        break;
+      case 'daemon.status':
+        result = await service.daemonStatus();
+        break;
+      case 'daemon.stop':
+        result = await service.shutdown();
+        shouldShutdown = true;
+        break;
+      default:
+        throw new Error(`Unknown command: ${envelope.command}`);
+    }
+
+    writeEnvelope(socket, {
+      id: envelope.id,
+      type: 'result',
+      data: result,
+    });
+    if (shouldShutdown) {
+      socket.end();
+      setTimeout(() => {
+        void shutdown();
+      }, 10).unref();
+    }
+  } catch (error) {
+    writeEnvelope(socket, {
+      id: envelope.id,
+      type: 'error',
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}