@controlflow-ai/daemon 0.1.0

package/src/client.ts

@@ -0,0 +1,310 @@
+import { defaultServerToken, defaultServerUrl } from './config.js';
+import { serverAuthHeaders } from './server-auth.js';
+import type { AgentRoomSubscriptionMode, AgentRun, AgentSession, ApiResponse, Chat, Computer, ComputerAgentAssignment, ComputerConnection, DaemonInstance, Message, MessageDelivery, ProvisionedComputer, RoomChannel, RoomParticipant, RunAction } from './types.js';
+
+export interface SendRequest {
+  chat?: string;
+  room?: string;
+  chat_id?: string;
+  room_id?: string;
+  parent_id?: number;
+  channel_id?: string | null;
+  sender: string;
+  recipient?: string | null;
+  content: string;
+  type?: 'message' | 'system';
+  idempotency_key?: string | null;
+  mentions?: string[];
+}
+
+export interface DaemonAuth {
+  computer_id: string;
+  connection_id: string;
+  token: string;
+}
+
+export interface StartRunRequest {
+  message_id: number;
+  agent: string;
+  cwd: string;
+  attempt: number;
+  pid?: number | null;
+  session_id?: string | null;
+  trigger_message_id?: number | null;
+  daemon_id?: string | null;
+  connection_id?: string | null;
+  computer_id?: string | null;
+  runtime_provider?: string | null;
+  runtime_invocation_id?: string | null;
+  delivery_id?: string | null;
+}
+
+export interface RegisterDaemonRequest {
+  id?: string;
+  name: string;
+  host?: string;
+  local_url?: string;
+  server_url?: string;
+  agents?: Array<{ agent: string; cwd?: string; capabilities?: Record<string, unknown> }>;
+}
+
+export interface ConnectComputerRequest {
+  computer_id?: string;
+  secret?: string;
+  api_key?: string;
+  name?: string;
+  host?: string;
+  local_url?: string;
+  server_url?: string;
+  agents?: Array<{ agent: string; cwd?: string; capabilities?: Record<string, unknown> }>;
+}
+
+export interface ProvisionComputerRequest {
+  name?: string;
+  server_url?: string;
+  package_name?: string;
+}
+
+export interface CreateDeliveryRequest {
+  message_id: number;
+  agent: string;
+}
+
+export interface ClaimDeliveryRequest {
+  daemon_id: string;
+  connection_id?: string | null;
+  computer_id?: string | null;
+  lease_ms?: number;
+}
+
+export interface GetOrCreateSessionRequest {
+  chat_id: string;
+  agent: string;
+  daemon_id: string;
+  connection_id?: string | null;
+  computer_id?: string | null;
+  runtime_provider?: string | null;
+  cwd: string;
+  last_message_id?: number | null;
+}
+
+export interface UpdateSessionRuntimeRequest {
+  runtime_session_id: string;
+}
+
+export interface FinishDeliveryRequest {
+  daemon_id: string;
+  connection_id?: string | null;
+  claim_token: string;
+  run_id?: string;
+  error?: string;
+}
+
+export interface FinishRunRequest {
+  status: AgentRun['status'];
+  exit_code?: number | null;
+  output?: string;
+}
+
+export interface CreateArtifactRequest {
+  content_base64: string;
+  mime_type: string;
+  title?: string;
+  filename?: string;
+  ttl_seconds?: number;
+}
+
+export class LockClient {
+  readonly baseUrl: string;
+  readonly daemonAuth: DaemonAuth | null;
+
+  constructor(baseUrl = defaultServerUrl(), daemonAuth: DaemonAuth | null = null) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.daemonAuth = daemonAuth;
+  }
+
+  async health(): Promise<{ status: string }> {
+    return this.get('/health');
+  }
+
+  async listChats(): Promise<Chat[]> {
+    const data = await this.get<{ chats: Chat[] }>('/api/chats');
+    return data.chats;
+  }
+
+  async listRooms(): Promise<Chat[]> {
+    const data = await this.get<{ rooms: Chat[] }>('/api/rooms');
+    return data.rooms;
+  }
+
+  async listRoomMembers(room: string): Promise<{ room: Chat; participants: RoomParticipant[]; completeness: string }> {
+    const data = await this.get<{ room: Chat; participants: RoomParticipant[]; completeness: string }>(`/api/rooms/${encodeURIComponent(room)}/members`);
+    return data;
+  }
+
+  async inviteAgentToRoom(room: string, input: { agent: string; mode?: AgentRoomSubscriptionMode }): Promise<{ participant: RoomParticipant; subscription: unknown }> {
+    return this.post<{ participant: RoomParticipant; subscription: unknown }>(`/api/rooms/${encodeURIComponent(room)}/agents`, input);
+  }
+
+  async createTopic(room: string, input: { name: string; created_by?: string | null }): Promise<RoomChannel> {
+    const data = await this.post<{ channel: RoomChannel }>(`/api/rooms/${encodeURIComponent(room)}/topics`, input);
+    return data.channel;
+  }
+
+  async getMessages(params: URLSearchParams): Promise<Message[]> {
+    const data = await this.get<{ messages: Message[] }>(`/api/messages?${params}`);
+    return data.messages;
+  }
+
+  async getInbox(agent: string, after = 0, limit = 50): Promise<Message[]> {
+    const params = new URLSearchParams({ agent, after: String(after), limit: String(limit) });
+    const data = await this.get<{ messages: Message[] }>(`/api/inbox?${params}`);
+    return data.messages;
+  }
+
+  async getMessage(id: number): Promise<Message> {
+    const data = await this.get<{ message: Message }>(`/api/messages/${id}`);
+    return data.message;
+  }
+
+  async sendMessage(input: SendRequest): Promise<Message> {
+    const data = await this.post<{ message: Message }>('/api/messages', input);
+    return data.message;
+  }
+
+  async provisionComputer(input: ProvisionComputerRequest = {}): Promise<ProvisionedComputer> {
+    const data = await this.post<ProvisionedComputer>('/api/computers/provision', input);
+    return data;
+  }
+
+  async listComputers(): Promise<Computer[]> {
+    const data = await this.get<{ computers: Computer[] }>('/api/computers');
+    return data.computers;
+  }
+
+  async connectComputer(input: ConnectComputerRequest): Promise<{ computer: Computer; connection: ComputerConnection; token: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }> {
+    const data = await this.post<{ computer: Computer; connection: ComputerConnection; token: string; daemon: DaemonInstance; agents: ComputerAgentAssignment[] }>('/api/computers/connect', input);
+    return data;
+  }
+
+  async heartbeatComputer(computerId: string): Promise<{ computer: Computer; connection: ComputerConnection; agents: ComputerAgentAssignment[] }> {
+    const data = await this.post<{ computer: Computer; connection: ComputerConnection; agents: ComputerAgentAssignment[] }>(`/api/computers/${encodeURIComponent(computerId)}/heartbeat`, {});
+    return data;
+  }
+
+  async registerDaemon(input: RegisterDaemonRequest): Promise<DaemonInstance> {
+    const data = await this.post<{ daemon: DaemonInstance }>('/api/daemons', input);
+    return data.daemon;
+  }
+
+  async listDeliveries(agent: string, status = 'pending', limit = 50): Promise<MessageDelivery[]> {
+    const params = new URLSearchParams({ agent, status, limit: String(limit) });
+    const data = await this.get<{ deliveries: MessageDelivery[] }>(`/api/deliveries?${params}`);
+    return data.deliveries;
+  }
+
+  async createDelivery(input: CreateDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>('/api/deliveries', input);
+    return data.delivery;
+  }
+
+  async claimDelivery(id: string, input: ClaimDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>(`/api/deliveries/${id}/claim`, input);
+    return data.delivery;
+  }
+
+  async ackDelivery(id: string, input: FinishDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>(`/api/deliveries/${id}/ack`, input);
+    return data.delivery;
+  }
+
+  async getOrCreateSession(input: GetOrCreateSessionRequest): Promise<AgentSession> {
+    const data = await this.post<{ session: AgentSession }>('/api/sessions', input);
+    return data.session;
+  }
+
+  async updateSessionRuntimeSessionId(id: string, input: UpdateSessionRuntimeRequest): Promise<AgentSession> {
+    const data = await this.post<{ session: AgentSession }>(`/api/sessions/${id}/runtime-session`, input);
+    return data.session;
+  }
+
+  async failDelivery(id: string, input: FinishDeliveryRequest): Promise<MessageDelivery> {
+    const data = await this.post<{ delivery: MessageDelivery }>(`/api/deliveries/${id}/fail`, input);
+    return data.delivery;
+  }
+
+  async createArtifact(input: CreateArtifactRequest, token = defaultServerToken()): Promise<{ artifact: unknown; token: string; url: string }> {
+    const data = await this.post<{ artifact: unknown; token: string; url: string }>('/api/artifacts', input, serverAuthHeaders(token));
+    return data;
+  }
+
+  async listArtifacts(token = defaultServerToken()): Promise<unknown[]> {
+    const data = await this.get<{ artifacts: unknown[] }>('/api/artifacts', serverAuthHeaders(token));
+    return data.artifacts;
+  }
+
+  async revokeArtifact(id: string, token = defaultServerToken()): Promise<unknown> {
+    const data = await this.post<{ artifact: unknown }>(`/api/artifacts/${id}/revoke`, {}, serverAuthHeaders(token));
+    return data.artifact;
+  }
+
+  async listRuns(): Promise<AgentRun[]> {
+    const data = await this.get<{ runs: AgentRun[] }>('/api/runs');
+    return data.runs;
+  }
+
+  async startRun(input: StartRunRequest): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>('/api/runs', input);
+    return data.run;
+  }
+
+  async updateRunPid(runId: string, pid: number | null): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>(`/api/runs/${runId}/pid`, { pid });
+    return data.run;
+  }
+
+  async finishRun(runId: string, input: FinishRunRequest): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>(`/api/runs/${runId}/finish`, input);
+    return data.run;
+  }
+
+  async requestRunAction(runId: string, action: RunAction): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>(`/api/runs/${runId}/${action}`, {});
+    return data.run;
+  }
+
+  async getRun(runId: string): Promise<AgentRun> {
+    const data = await this.get<{ run: AgentRun }>(`/api/runs/${runId}`);
+    return data.run;
+  }
+
+  private async get<T>(path: string, headers?: HeadersInit): Promise<T> {
+    return this.request<T>(path, { method: 'GET', headers: { ...this.daemonAuthHeaders(), ...headers } });
+  }
+
+  private async post<T>(path: string, body: unknown, headers?: HeadersInit): Promise<T> {
+    return this.request<T>(path, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.daemonAuthHeaders(), ...headers },
+      body: JSON.stringify(body),
+    });
+  }
+
+  private daemonAuthHeaders(): HeadersInit {
+    if (!this.daemonAuth) return {};
+    return {
+      'x-pal-computer-id': this.daemonAuth.computer_id,
+      'x-pal-connection-id': this.daemonAuth.connection_id,
+      'x-pal-connection-token': this.daemonAuth.token,
+    };
+  }
+
+  private async request<T>(path: string, init: RequestInit): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${path}`, init);
+    const payload = await response.json() as ApiResponse<T>;
+    if (!response.ok || !payload.ok) {
+      throw new Error(payload.message ?? `request failed: ${response.status}`);
+    }
+    return payload.data as T;
+  }
+}

package/src/coco.ts

@@ -0,0 +1,52 @@
+import { buildPalPrompt, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+export { runAgentRuntime } from './agent-runtime.js';
+
+function extractSessionId(stdout: string): string | null {
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) continue;
+    try {
+      const event = JSON.parse(trimmed) as { session_id?: unknown };
+      if (typeof event.session_id === 'string' && event.session_id.trim()) {
+        return event.session_id;
+      }
+    } catch {
+      // Non-JSON stdout is kept in output; it just is not a JSONL event.
+    }
+  }
+  return null;
+}
+
+export function makeCocoRuntime(_agentUuid: string): AgentRuntime {
+  return {
+    name: 'coco',
+    capabilities: { protocol: 'acp', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: true },
+    command: 'coco',
+    buildPrompt: buildPalPrompt,
+    buildCwd: runtimeCwd,
+    buildArgs(input: AgentRuntimeRunInput): string[] {
+      return ['acp', 'serve', '-y', ...input.extraArgs];
+    },
+  };
+}
+
+export function makeCocoStreamJsonRuntime(_agentUuid: string): AgentRuntime {
+  return {
+    name: 'coco-stream-json',
+    capabilities: { protocol: 'json-stream', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: false },
+    command: 'coco',
+    buildPrompt: buildPalPrompt,
+    buildCwd: runtimeCwd,
+    buildArgs(input: AgentRuntimeRunInput): string[] {
+      const prompt = buildPalPrompt(input);
+      const resumeArgs = input.runtimeSessionId ? ['--resume', input.runtimeSessionId] : [];
+      return ['-y', '-p', '--output-format', 'stream-json', ...resumeArgs, ...input.extraArgs, prompt];
+    },
+    parseOutput({ stdout, stderr, input }) {
+      return {
+        output: [stdout.trim(), stderr.trim()].filter(Boolean).join('\n'),
+        runtimeSessionId: extractSessionId(stdout) ?? input.runtimeSessionId ?? null,
+      };
+    },
+  };
+}

package/src/codex.ts

@@ -0,0 +1,41 @@
+import { buildPalPrompt, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+export { runAgentRuntime } from './agent-runtime.js';
+
+function extractThreadId(stdout: string): string | null {
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) continue;
+    try {
+      const event = JSON.parse(trimmed) as { type?: unknown; thread_id?: unknown };
+      if (event.type === 'thread.started' && typeof event.thread_id === 'string' && event.thread_id.trim()) {
+        return event.thread_id;
+      }
+    } catch {
+      // Non-JSON stdout is kept in output; it just is not a JSONL event.
+    }
+  }
+  return null;
+}
+
+export function makeCodexRuntime(_agentUuid: string): AgentRuntime {
+  return {
+    name: 'codex',
+    capabilities: { protocol: 'json-stream', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: false },
+    command: 'codex',
+    buildPrompt: buildPalPrompt,
+    buildCwd: runtimeCwd,
+    buildArgs(input: AgentRuntimeRunInput): string[] {
+      const prompt = buildPalPrompt(input);
+      if (input.runtimeSessionId) {
+        return ['exec', 'resume', '--json', '--dangerously-bypass-approvals-and-sandbox', ...input.extraArgs, input.runtimeSessionId, prompt];
+      }
+      return ['exec', '--json', '--dangerously-bypass-approvals-and-sandbox', '--cd', runtimeCwd(input), ...input.extraArgs, prompt];
+    },
+    parseOutput({ stdout, stderr, input }) {
+      return {
+        output: [stdout.trim(), stderr.trim()].filter(Boolean).join('\n'),
+        runtimeSessionId: extractThreadId(stdout) ?? input.runtimeSessionId ?? null,
+      };
+    },
+  };
+}

package/src/coding-agent-runtime.ts

@@ -0,0 +1,20 @@
+export {
+  buildPalPrompt,
+  formatRecentMessageContext,
+  formatRoomParticipantContext,
+  runAgentRuntime,
+  runCodingAgent,
+  runtimeCwd,
+  runtimeProjectCwd,
+} from './agent-runtime.js';
+export type {
+  AgentRuntime,
+  AgentRuntimeCapabilities,
+  AgentRuntimeProtocol,
+  AgentRuntimeRunInput,
+  AgentRuntimeRunResult,
+  CodingAgentRunInput,
+  CodingAgentRunResult,
+  CodingAgentRuntime,
+  RuntimeDriver,
+} from './agent-runtime.js';

package/src/config.ts

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+export const DEFAULT_PORT = 4127;
+export const DEFAULT_HOST = '127.0.0.1';
+export const DEFAULT_DAEMON_PORT = 4137;
+
+export function homeDir(): string {
+  return resolve(process.env.PAL_HOME ?? join(homedir(), '.pal'));
+}
+
+export function defaultServerUrl(): string {
+  return process.env.LOCK_SERVER_URL ?? process.env.PAL_SERVER ?? `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;
+}
+
+export function defaultDaemonUrl(): string {
+  return process.env.LOCK_DAEMON_URL ?? `http://${DEFAULT_HOST}:${DEFAULT_DAEMON_PORT}`;
+}
+
+export function defaultDaemonToken(): string | undefined {
+  return process.env.LOCK_DAEMON_TOKEN;
+}
+
+export function defaultServerToken(): string | undefined {
+  return process.env.LOCK_SERVER_TOKEN;
+}
+
+export function defaultDbPath(): string {
+  return resolve(process.env.PAL_DB ?? join(homeDir(), 'lock.sqlite'));
+}
+
+export function defaultStatePath(agent: string): string {
+  return join(homeDir(), 'daemon', `${agent}.json`);
+}
+
+export function agentHomePath(agentUuid: string): string {
+  return join(homeDir(), 'agents', agentUuid);
+}
+
+export function ensureParentDir(path: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+}
+
+export function ensureDir(path: string): void {
+  mkdirSync(path, { recursive: true });
+}
+
+export function ensureAgentHome(path: string, agentKey: string, runtime: string): void {
+  ensureDir(path);
+  ensureDir(join(path, 'state'));
+  ensureDir(join(path, 'kb'));
+  ensureDir(join(path, 'archive'));
+
+  const memoryPath = join(path, 'MEMORY.md');
+  if (!existsSync(memoryPath)) {
+    writeFileSync(memoryPath, `# ${agentKey}
+
+## Active Context
+- Current focus: Fresh PAL agent home initialized.
+
+## Recovery Read Order
+1. Read state/active-task.json when it exists.
+2. Read state/open-loops.json when it exists.
+3. Read state/active-context.md when it exists.
+4. Read relevant kb/* notes when needed.
+
+## Memory Map
+- kb/index.md: durable local knowledge index.
+- state/: current task and recovery state.
+- archive/: historical fallback notes.
+`);
+  }
+
+  const soulPath = join(path, 'SOUL.md');
+  if (!existsSync(soulPath)) {
+    writeFileSync(soulPath, `# ${agentKey}
+
+## Purpose
+Persistent PAL agent.
+
+## Defaults
+- runtime: ${runtime}
+
+## Notes
+- This file is local to the agent home and may be edited by the agent.
+`);
+  }
+}
+
+export function repoCliPath(): string {
+  return resolve(import.meta.dir, 'cli.ts');
+}
+
+export function privatePalCliBinDir(): string {
+  return join(homeDir(), 'bin');
+}
+
+export function ensurePrivatePalCliBin(): string {
+  const binDir = privatePalCliBinDir();
+  ensureDir(binDir);
+  const linkPath = join(binDir, 'pal');
+  rmSync(linkPath, { force: true });
+  symlinkSync(repoCliPath(), linkPath);
+  return binDir;
+}