@controlflow-ai/daemon 0.1.1 → 0.1.3

package/src/runtime-registry.ts

@@ -3,23 +3,19 @@ import type { AgentRuntime, AgentRuntimeProtocol } from './agent-runtime.js';
 const supportedProtocols = new Set<AgentRuntimeProtocol>(['json-stream', 'acp']);
 
 const runtimeFactories = {
-  codex: async (agentUuid: string): Promise<AgentRuntime> => {
+  codex: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeCodexRuntime } = await import('./codex.js');
-    return makeCodexRuntime(agentUuid);
+    return makeCodexRuntime(agentUuid, model);
   },
-  coco: async (agentUuid: string): Promise<AgentRuntime> => {
+  coco: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeCocoRuntime } = await import('./coco.js');
-    return makeCocoRuntime(agentUuid);
+    return makeCocoRuntime(agentUuid, model);
   },
-  'coco-stream-json': async (agentUuid: string): Promise<AgentRuntime> => {
-    const { makeCocoStreamJsonRuntime } = await import('./coco.js');
-    return makeCocoStreamJsonRuntime(agentUuid);
-  },
-  neeko: async (agentUuid: string): Promise<AgentRuntime> => {
+  neeko: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeNeekoRuntime } = await import('./neeko.js');
-    return makeNeekoRuntime(agentUuid);
+    return makeNeekoRuntime(agentUuid, model);
   },
-} satisfies Record<string, (agentUuid: string) => Promise<AgentRuntime>>;
+} satisfies Record<string, (agentUuid: string, model: string | null) => Promise<AgentRuntime>>;
 
 export type RuntimeName = keyof typeof runtimeFactories;
 
@@ -27,13 +23,87 @@ export function knownRuntimeNames(): RuntimeName[] {
   return Object.keys(runtimeFactories) as RuntimeName[];
 }
 
-export async function resolveRuntimeDriver(runtimeName: string, agentUuid: string): Promise<AgentRuntime> {
+export interface RuntimeModelLookup {
+  models: string[];
+  error: string | null;
+}
+
+function modelCommand(runtimeName: string): { command: string; args: string[] } {
+  if (runtimeName === 'codex') return { command: 'codex', args: ['debug', 'models'] };
+  if (runtimeName === 'coco') return { command: 'coco', args: ['models'] };
+  if (runtimeName === 'neeko') return { command: 'neeko', args: ['models'] };
+  throw new Error(`Unsupported runtime '${runtimeName}'. Supported runtimes: ${knownRuntimeNames().join(', ')}.`);
+}
+
+function stripAnsi(value: string): string {
+  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+}
+
+function uniqueNonEmpty(values: string[]): string[] {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+
+function parseModelOutput(runtimeName: string, stdout: string): string[] {
+  const clean = stripAnsi(stdout).trim();
+  if (!clean) return [];
+  if (runtimeName === 'codex') {
+    const parsed = JSON.parse(clean) as { models?: Array<{ slug?: unknown; id?: unknown; name?: unknown }> };
+    return uniqueNonEmpty((parsed.models ?? []).map((model) => String(model.slug ?? model.id ?? model.name ?? '')));
+  }
+  return uniqueNonEmpty(clean.split(/\r?\n/).filter((line) => !/^\s*(available\s+)?models\s*:?\s*$/i.test(line)));
+}
+
+export async function runtimeModelOptions(runtimeName: string): Promise<string[]> {
+  const runtime = runtimeName.trim();
+  modelCommand(runtime);
+  const { command, args } = modelCommand(runtime);
+  const proc = Bun.spawn([command, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: process.env,
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    const detail = stderr.trim() || stdout.trim() || `exit ${exitCode}`;
+    throw new Error(`Could not load models for runtime '${runtime}': ${detail}`);
+  }
+  return parseModelOutput(runtime, stdout);
+}
+
+export async function lookupRuntimeModels(runtimeName: string): Promise<RuntimeModelLookup> {
+  try {
+    return { models: await runtimeModelOptions(runtimeName), error: null };
+  } catch (error) {
+    return { models: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function allRuntimeModelOptions(): Promise<Record<RuntimeName, RuntimeModelLookup>> {
+  const entries = await Promise.all(knownRuntimeNames().map(async (name) => [name, await lookupRuntimeModels(name)] as const));
+  return Object.fromEntries(entries) as Record<RuntimeName, RuntimeModelLookup>;
+}
+
+export async function validateRuntimeModel(runtimeName: string, model: string | null | undefined): Promise<string | null> {
+  const trimmed = model?.trim() || null;
+  if (!trimmed) return null;
+  const options = await runtimeModelOptions(runtimeName);
+  if (!options.includes(trimmed)) {
+    throw new Error(`Unsupported model '${trimmed}' for runtime '${runtimeName}'. Supported models: ${options.join(', ')}.`);
+  }
+  return trimmed;
+}
+
+export async function resolveRuntimeDriver(runtimeName: string, agentUuid: string, model?: string | null): Promise<AgentRuntime> {
   const factory = runtimeFactories[runtimeName as RuntimeName];
   if (!factory) {
     throw new Error(`Unsupported runtime '${runtimeName}'. Supported runtimes: ${knownRuntimeNames().join(', ')}.`);
   }
 
-  const driver = await factory(agentUuid);
+  const driver = await factory(agentUuid, model?.trim() || null);
   if (!supportedProtocols.has(driver.capabilities.protocol)) {
     throw new Error(`Runtime '${runtimeName}' uses unsupported protocol '${driver.capabilities.protocol}'. Supported protocols: ${Array.from(supportedProtocols).join(', ')}.`);
   }

package/src/server.ts

@@ -1,34 +1,101 @@
 #!/usr/bin/env bun
+import { randomUUID } from 'node:crypto';
 import { DEFAULT_HOST, DEFAULT_PORT, defaultDbPath } from './config.js';
 import { MessageStore } from './db.js';
-import { handleRequest } from './app.js';
+import { fireDueRoomRemindersForDelivery, handleRequest } from './app.js';
+import { DeliveryWebSocketHub, type DeliveryWebSocketData } from './delivery-ws.js';
 import { startLarkOnServer } from './lark/server-integration.js';
+import { buildMessagingHealthLogLines, buildMessagingStatus } from './messaging-status.js';
 import { isLoopbackHost, tailscaleAddress } from './network.js';
+import { assertServerAuth } from './server-auth.js';
 
 const dbPath = defaultDbPath();
 const store = new MessageStore(dbPath);
+const bootId = randomUUID();
+const bootedAt = new Date();
 const port = Number(process.env.PAL_PORT ?? DEFAULT_PORT);
 const host = process.env.PAL_HOST ?? DEFAULT_HOST;
 const tailscaleHost = process.env.PAL_TAILSCALE_HOST ?? tailscaleAddress();
+const larkAutoRestartStaleAfterMs = positiveEnvMs('PAL_LARK_AUTO_RESTART_STALE_AFTER_MS');
+const larkAutoRestartIntervalMs = positiveEnvMs('PAL_LARK_AUTO_RESTART_INTERVAL_MS') ?? Math.min(larkAutoRestartStaleAfterMs ?? 60_000, 60_000);
+const larkAutoRestartMinIntervalMs = positiveEnvMs('PAL_LARK_AUTO_RESTART_MIN_INTERVAL_MS') ?? Math.max(larkAutoRestartStaleAfterMs ?? 0, 5 * 60 * 1000);
+const messagingHealthLogIntervalMs = nonNegativeEnvMs('PAL_MESSAGING_HEALTH_LOG_INTERVAL_MS') ?? 60_000;
+const computerConnectionTimeoutMs = nonNegativeEnvMs('PAL_COMPUTER_CONNECTION_TIMEOUT_MS') ?? 30_000;
+const computerConnectionCleanupIntervalMs = positiveEnvMs('PAL_COMPUTER_CONNECTION_CLEANUP_INTERVAL_MS') ?? Math.min(Math.max(computerConnectionTimeoutMs, 5_000), 60_000);
+const reminderFireIntervalMs = nonNegativeEnvMs('PAL_REMINDER_FIRE_INTERVAL_MS') ?? 1_000;
+const reminderFireLimit = positiveEnvMs('PAL_REMINDER_FIRE_LIMIT') ?? 25;
+const deliveryWs = new DeliveryWebSocketHub(store, { staleConnectionTimeoutMs: computerConnectionTimeoutMs });
+const lastMessagingHealthLogAt = new Map<string, number>();
 
-function fetch(request: Request): Promise<Response> | Response {
+function positiveEnvMs(name: string): number | null {
+  const raw = process.env[name];
+  if (!raw) return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function nonNegativeEnvMs(name: string): number | null {
+  const raw = process.env[name];
+  if (raw === undefined || raw === '') return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+function fetch(request: Request, server: Bun.Server<DeliveryWebSocketData>): Promise<Response> | Response {
+  const upgraded = deliveryWs.handleUpgrade(request, server);
+  if (upgraded) return upgraded;
   const url = new URL(request.url);
+  if (request.method === 'GET' && url.pathname === '/api/server/runtime') {
+    try {
+      assertServerAuth(request);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'unauthorized';
+      return new Response(JSON.stringify({ ok: false, error: message }), {
+        status: 401,
+        headers: { 'content-type': 'application/json; charset=utf-8' },
+      });
+    }
+    return new Response(JSON.stringify({
+      ok: true,
+      data: {
+        boot_id: bootId,
+        booted_at: bootedAt.toISOString(),
+        uptime_ms: Date.now() - bootedAt.getTime(),
+      },
+    }), {
+      headers: { 'content-type': 'application/json; charset=utf-8' },
+    });
+  }
+  if (request.method === 'GET' && url.pathname === '/api/lark/status') {
+    return larkStatus();
+  }
   if (request.method === 'POST' && url.pathname === '/api/lark/reload') {
     return reloadLarkIntegration();
   }
-  return handleRequest(store, request);
+  if (request.method === 'POST' && url.pathname === '/api/lark/restart') {
+    return restartLarkIntegration(request);
+  }
+  if (request.method === 'POST' && url.pathname === '/api/lark/probe-event') {
+    return probeLarkEvent(request, url);
+  }
+  return handleRequest(store, request, {
+    deliveryNotifier: deliveryWs,
+    larkStatusProvider: () => larkIntegration.status(),
+  });
 }
 
 const server = Bun.serve({
   hostname: host,
   port,
   fetch,
+  websocket: deliveryWs.websocket,
 });
 const tailscaleServer = tailscaleHost && isLoopbackHost(host)
-  ? Bun.serve({ hostname: tailscaleHost, port, fetch })
+  ? Bun.serve({ hostname: tailscaleHost, port, fetch, websocket: deliveryWs.websocket })
   : null;
 
 console.log(`pal server listening on http://${server.hostname}:${server.port}`);
+console.log(`[server] boot id=${bootId} started_at=${bootedAt.toISOString()}`);
 if (tailscaleServer) {
   console.log(`pal server also listening on Tailscale http://${tailscaleServer.hostname}:${tailscaleServer.port}`);
 } else if (tailscaleHost) {
@@ -36,15 +103,98 @@ if (tailscaleServer) {
 }
 console.log(`database: ${dbPath}`);
 
+const computerConnectionCleanup = setInterval(() => {
+  const closed = deliveryWs.pruneStaleConnections();
+  if (closed > 0) {
+    console.log(`[server] closed stale computer connection(s): ${closed}`);
+  }
+}, computerConnectionCleanupIntervalMs);
+console.log(`[server] computer connection cleanup enabled timeout_ms=${computerConnectionTimeoutMs} interval_ms=${computerConnectionCleanupIntervalMs}`);
+
+function fireDueReminderWakeups(): void {
+  try {
+    const result = fireDueRoomRemindersForDelivery(store, { deliveryNotifier: deliveryWs }, { limit: reminderFireLimit });
+    if (result.reminders.length > 0) {
+      console.log(`[server] fired room reminders reminders=${result.reminders.length} messages=${result.messages.length} deliveries=${result.deliveries.length}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[server] room reminder firing failed: ${message}`);
+  }
+}
+
+const roomReminderFireLoop = reminderFireIntervalMs > 0
+  ? setInterval(fireDueReminderWakeups, reminderFireIntervalMs)
+  : null;
+if (roomReminderFireLoop) {
+  console.log(`[server] room reminder firing enabled interval_ms=${reminderFireIntervalMs} limit=${reminderFireLimit}`);
+  fireDueReminderWakeups();
+} else {
+  console.log('[server] room reminder firing disabled');
+}
+
 function startLarkIntegration() {
   return startLarkOnServer({
     store,
+    dbPath,
+    deliveryNotifier: deliveryWs,
     logger: { log: console.log, warn: console.warn, error: console.error },
   });
 }
 
 // Start Lark bot integration on the server
 let larkIntegration = startLarkIntegration();
+const larkAutoRestart = larkAutoRestartStaleAfterMs
+  ? setInterval(() => {
+    const result = larkIntegration.restartStale({
+      staleAfterMs: larkAutoRestartStaleAfterMs,
+      minRestartIntervalMs: larkAutoRestartMinIntervalMs,
+    });
+    if (result.restarted.length > 0) {
+      console.log(`[server] lark auto-restarted stale websocket(s): ${result.restarted.join(',')}`);
+    }
+    if (result.skipped_recent?.length) {
+      console.log(`[server] lark auto-restart skipped recent websocket(s): ${result.skipped_recent.join(',')}`);
+    }
+    if (result.skipped_ineffective?.length) {
+      console.warn(`[server] lark auto-restart skipped ineffective websocket repair(s): ${result.skipped_ineffective.join(',')}`);
+    }
+    if (!result.ok) {
+      console.warn(`[server] lark auto-restart failed: ${result.error}`);
+    }
+    logMessagingHealthDiagnostics();
+  }, larkAutoRestartIntervalMs)
+  : null;
+if (larkAutoRestart) {
+  console.log(`[server] lark stale auto-restart enabled stale_after_ms=${larkAutoRestartStaleAfterMs} interval_ms=${larkAutoRestartIntervalMs} min_restart_interval_ms=${larkAutoRestartMinIntervalMs}`);
+}
+const messagingHealthLog = messagingHealthLogIntervalMs > 0
+  ? setInterval(logMessagingHealthDiagnostics, messagingHealthLogIntervalMs)
+  : null;
+if (messagingHealthLog) {
+  console.log(`[server] messaging health logging enabled interval_ms=${messagingHealthLogIntervalMs}`);
+} else {
+  console.log('[server] messaging health logging disabled');
+}
+
+function logMessagingHealthDiagnostics(): void {
+  const now = Date.now();
+  const larkBots = larkIntegration.status();
+  const deliveryWebSocket = deliveryWs.statsAllConnections();
+  const lines = buildMessagingHealthLogLines(buildMessagingStatus({ larkBots, deliveryWebSocket }));
+  for (const line of lines) {
+    const previous = lastMessagingHealthLogAt.get(line.throttle_key) ?? 0;
+    if (now - previous < 5 * 60 * 1000) continue;
+    lastMessagingHealthLogAt.set(line.throttle_key, now);
+    console.warn(`[server] ${line.message}`);
+  }
+}
+
+function larkStatus(): Response {
+  return new Response(JSON.stringify({ ok: true, data: { bots: larkIntegration.status() } }), {
+    headers: { 'content-type': 'application/json' },
+  });
+}
 
 async function reloadLarkIntegration(): Promise<Response> {
   const result = larkIntegration.reload();
@@ -56,17 +206,107 @@ async function reloadLarkIntegration(): Promise<Response> {
     headers: { 'content-type': 'application/json' },
   });
 }
+
+async function restartLarkIntegration(request: Request): Promise<Response> {
+  let appIds: string[] | undefined;
+  try {
+    const body = request.headers.get('content-type')?.includes('application/json')
+      ? await request.json() as { app_id?: unknown; app_ids?: unknown }
+      : {};
+    if (typeof body.app_id === 'string' && body.app_id.trim()) {
+      appIds = [body.app_id.trim()];
+    } else if (Array.isArray(body.app_ids)) {
+      appIds = body.app_ids.filter((id): id is string => typeof id === 'string' && id.trim().length > 0).map((id) => id.trim());
+    }
+  } catch {
+    return new Response(JSON.stringify({ ok: false, error: 'invalid JSON body' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  const result = larkIntegration.restart(appIds);
+  if (result.ok && result.restarted.length > 0) {
+    console.log(`[server] lark restarted: ${result.restarted.join(',')}`);
+  }
+  return new Response(JSON.stringify(result.ok ? { ok: true, data: result } : { ok: false, error: result.error, data: { bots: result.bots, restarted: result.restarted, missing: result.missing } }), {
+    status: result.ok ? 200 : 500,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+
+async function probeLarkEvent(request: Request, url: URL): Promise<Response> {
+  if (!isLoopbackHost(url.hostname)) {
+    return new Response(JSON.stringify({ ok: false, error: 'Lark probe is only available through a loopback server URL' }), {
+      status: 403,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  try {
+    assertServerAuth(request);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'unauthorized';
+    return new Response(JSON.stringify({ ok: false, error: message }), {
+      status: 401,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  let body: { app_id?: unknown; envelope?: unknown; data?: unknown };
+  try {
+    body = await request.json() as { app_id?: unknown; envelope?: unknown; data?: unknown };
+  } catch {
+    return new Response(JSON.stringify({ ok: false, error: 'invalid JSON body' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  if (typeof body.app_id !== 'string' || !body.app_id.trim()) {
+    return new Response(JSON.stringify({ ok: false, error: 'app_id is required' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  if (body.data === undefined || body.data === null || typeof body.data !== 'object') {
+    return new Response(JSON.stringify({ ok: false, error: 'data object is required' }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  try {
+    const result = await larkIntegration.injectProbeEvent({
+      appId: body.app_id,
+      envelope: typeof body.envelope === 'string' && body.envelope.trim() ? body.envelope : undefined,
+      data: body.data,
+    });
+    return new Response(JSON.stringify({ ok: true, data: result }), {
+      headers: { 'content-type': 'application/json' },
+    });
+  } catch (err) {
+    return new Response(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+}
+
 if (larkIntegration.handles.length > 0) {
   console.log(`[server] lark integrated: ${larkIntegration.handles.map((h) => h.appId).join(',')}`);
 }
 
 process.on('SIGINT', () => {
+  if (larkAutoRestart) clearInterval(larkAutoRestart);
+  if (messagingHealthLog) clearInterval(messagingHealthLog);
+  clearInterval(computerConnectionCleanup);
+  deliveryWs.close();
   larkIntegration.stop();
   tailscaleServer?.stop();
   server.stop();
   process.exit(0);
 });
 process.on('SIGTERM', () => {
+  if (larkAutoRestart) clearInterval(larkAutoRestart);
+  if (messagingHealthLog) clearInterval(messagingHealthLog);
+  clearInterval(computerConnectionCleanup);
+  deliveryWs.close();
   larkIntegration.stop();
   tailscaleServer?.stop();
   server.stop();

package/src/token-file.ts

@@ -5,7 +5,11 @@ import { homeDir } from './config.js';
 
 const TOKEN_BYTES = 32;
 
-function assertPrivateDir(path: string): void {
+export interface DaemonTokenFileOptions {
+  platform?: NodeJS.Platform;
+}
+
+function assertPrivateDir(path: string, platform: NodeJS.Platform): void {
   if (!existsSync(path)) {
     mkdirSync(path, { recursive: true, mode: 0o700 });
   }
@@ -14,6 +18,7 @@ function assertPrivateDir(path: string): void {
   if (link.isSymbolicLink()) throw new Error(`unsafe token directory: ${path} is a symlink`);
   const stat = statSync(path);
   if (!stat.isDirectory()) throw new Error(`unsafe token directory: ${path} is not a directory`);
+  if (platform === 'win32') return;
   if ((stat.mode & 0o777) !== 0o700) {
     chmodSync(path, 0o700);
     const fixed = statSync(path);
@@ -21,11 +26,12 @@ function assertPrivateDir(path: string): void {
   }
 }
 
-function assertPrivateTokenFile(path: string): void {
+function assertPrivateTokenFile(path: string, platform: NodeJS.Platform): void {
   const link = lstatSync(path);
   if (link.isSymbolicLink()) throw new Error(`unsafe token file: ${path} is a symlink`);
   const stat = statSync(path);
   if (!stat.isFile()) throw new Error(`unsafe token file: ${path} is not a regular file`);
+  if (platform === 'win32') return;
   if ((stat.mode & 0o177) !== 0) throw new Error(`unsafe token file: ${path} permissions must be 0600`);
 }
 
@@ -38,12 +44,13 @@ export function legacyTokenPath(): string {
   return join(homeDir(), 'daemon-token');
 }
 
-export function loadOrCreateDaemonToken(path = defaultTokenPath()): string {
+export function loadOrCreateDaemonToken(path = defaultTokenPath(), options: DaemonTokenFileOptions = {}): string {
+  const platform = options.platform ?? process.platform;
   const resolved = resolve(path);
-  assertPrivateDir(dirname(resolved));
+  assertPrivateDir(dirname(resolved), platform);
 
   if (existsSync(resolved)) {
-    assertPrivateTokenFile(resolved);
+    assertPrivateTokenFile(resolved, platform);
     const token = readFileSync(resolved, 'utf8').trim();
     if (!token) throw new Error(`empty token file: ${resolved}`);
     return token;
@@ -52,6 +59,6 @@ export function loadOrCreateDaemonToken(path = defaultTokenPath()): string {
   const token = crypto.getRandomValues(new Uint8Array(TOKEN_BYTES)).reduce((value, byte) => value + byte.toString(16).padStart(2, '0'), '');
   const fd = openSync(resolved, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
   writeFileSync(fd, `${token}\n`);
-  assertPrivateTokenFile(resolved);
+  assertPrivateTokenFile(resolved, platform);
   return token;
 }