@controlflow-ai/daemon 0.1.0

package/src/migrations/018_room_display_names.ts

@@ -0,0 +1,36 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 18;
+export const name = 'room_display_names';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'chats', 'display_name')) {
+    db.exec(`ALTER TABLE chats ADD COLUMN display_name TEXT`);
+  }
+
+  db.exec(`
+    DROP VIEW IF EXISTS chat_stats;
+    CREATE VIEW chat_stats AS
+    SELECT
+      c.id,
+      c.name,
+      c.display_name,
+      c.kind,
+      c.server_id,
+      c.provider,
+      c.dm_type,
+      c.capabilities_json,
+      c.audit_visibility,
+      c.created_at,
+      COUNT(m.id) AS message_count,
+      MAX(m.created_at) AS last_message_at
+    FROM chats c
+    LEFT JOIN messages m ON m.chat_id = c.id
+    GROUP BY c.id;
+  `);
+}

package/src/migrations/019_computer_connections.ts

@@ -0,0 +1,63 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 19;
+export const name = 'computer_connections';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+function addColumnIfMissing(db: Database, table: string, column: string, ddl: string): void {
+  if (!hasColumn(db, table, column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+  }
+}
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS computers (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL DEFAULT '',
+      credential_hash TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'offline' CHECK (status IN ('online', 'offline', 'revoked')),
+      active_connection_id TEXT,
+      last_seen_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS computer_connections (
+      id TEXT PRIMARY KEY,
+      computer_id TEXT NOT NULL REFERENCES computers(id) ON DELETE CASCADE,
+      token_hash TEXT NOT NULL,
+      epoch INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'revoked', 'closed')),
+      connected_at TEXT NOT NULL DEFAULT (datetime('now')),
+      last_heartbeat_at TEXT NOT NULL DEFAULT (datetime('now')),
+      revoked_at TEXT,
+      UNIQUE(computer_id, epoch)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_computer_connections_computer_status
+      ON computer_connections(computer_id, status, epoch);
+  `);
+
+  addColumnIfMissing(db, 'message_deliveries', 'connection_id', 'connection_id TEXT REFERENCES computer_connections(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_sessions', 'computer_id', 'computer_id TEXT REFERENCES computers(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_sessions', 'runtime_provider', 'runtime_provider TEXT');
+  addColumnIfMissing(db, 'agent_runs', 'computer_id', 'computer_id TEXT REFERENCES computers(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_runs', 'connection_id', 'connection_id TEXT REFERENCES computer_connections(id) ON DELETE SET NULL');
+  addColumnIfMissing(db, 'agent_runs', 'runtime_provider', 'runtime_provider TEXT');
+  addColumnIfMissing(db, 'agent_runs', 'runtime_invocation_id', 'runtime_invocation_id TEXT');
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_message_deliveries_connection_id ON message_deliveries(connection_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_connection_id ON agent_runs(connection_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_computer_room_active
+      ON agent_runs(computer_id, agent, status, session_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_agent_sessions_computer_context
+      ON agent_sessions(chat_id, agent, computer_id, runtime_provider)
+      WHERE computer_id IS NOT NULL AND runtime_provider IS NOT NULL;
+  `);
+}

package/src/migrations/020_computer_agent_assignments.ts

@@ -0,0 +1,20 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 20;
+export const name = 'computer_agent_assignments';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS computer_agent_assignments (
+      agent TEXT PRIMARY KEY REFERENCES agents(agent_key) ON DELETE CASCADE,
+      computer_id TEXT NOT NULL REFERENCES computers(id) ON DELETE CASCADE,
+      cwd TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_computer_agent_assignments_computer
+      ON computer_agent_assignments(computer_id, status, agent);
+  `);
+}

package/src/migrations/021_provider_identity_bindings.ts

@@ -0,0 +1,32 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 21;
+export const name = 'provider_identity_bindings';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS pal_identities (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL CHECK (kind IN ('user', 'bot', 'agent', 'room')),
+      display_name TEXT,
+      stable_handle TEXT NOT NULL UNIQUE,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS provider_identity_bindings (
+      id TEXT PRIMARY KEY,
+      provider TEXT NOT NULL CHECK (provider IN ('lark', 'wechat')),
+      provider_account_id TEXT NOT NULL REFERENCES provider_accounts(id) ON DELETE CASCADE,
+      external_type TEXT NOT NULL CHECK (external_type IN ('user', 'bot', 'room')),
+      external_id TEXT NOT NULL,
+      identity_id TEXT NOT NULL REFERENCES pal_identities(id) ON DELETE CASCADE,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(provider, provider_account_id, external_type, external_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_provider_identity_bindings_identity
+      ON provider_identity_bindings(identity_id);
+  `);
+}

package/src/migrations.ts

@@ -0,0 +1,85 @@
+import type { Database } from 'bun:sqlite';
+import * as initial from './migrations/001_initial.js';
+import * as daemonDeliveries from './migrations/002_daemon_deliveries.js';
+import * as sessionsRuns from './migrations/003_sessions_runs.js';
+import * as messageIdempotency from './migrations/004_message_idempotency.js';
+import * as artifacts from './migrations/005_artifacts.js';
+import * as larkChannelFoundation from './migrations/006_lark_channel_foundation.js';
+import * as agentsA0 from './migrations/007_agents_a0.js';
+import * as b0ChatHistory from './migrations/008_b0_chat_history.js';
+import * as b0TranscriptIngestSeq from './migrations/009_b0_transcript_ingest_seq.js';
+import * as b0TranscriptShadowExternalIds from './migrations/010_b0_transcript_shadow_external_ids.js';
+import * as b0ChannelConversationAuditOnly from './migrations/011_b0_channel_conversation_audit_only.js';
+import * as b0CrossConversationInvariant from './migrations/012_b0_cross_conversation_invariant.js';
+import * as b10EngInboundRawEvents from './migrations/013_b1_0_eng_inbound_raw_events.js';
+import * as agentsRuntime from './migrations/014_agents_runtime.js';
+import * as agentRuntimeSessions from './migrations/015_agent_runtime_sessions.js';
+import * as roomParticipants from './migrations/016_room_participants.js';
+import * as unifiedRoomDelivery from './migrations/017_unified_room_delivery.js';
+import * as roomDisplayNames from './migrations/018_room_display_names.js';
+import * as computerConnections from './migrations/019_computer_connections.js';
+import * as computerAgentAssignments from './migrations/020_computer_agent_assignments.js';
+import * as providerIdentityBindings from './migrations/021_provider_identity_bindings.js';
+
+interface Migration {
+  version: number;
+  name: string;
+  up(db: Database): void;
+}
+
+const migrations: Migration[] = [initial, daemonDeliveries, sessionsRuns, messageIdempotency, artifacts, larkChannelFoundation, agentsA0, b0ChatHistory, b0TranscriptIngestSeq, b0TranscriptShadowExternalIds, b0ChannelConversationAuditOnly, b0CrossConversationInvariant, b10EngInboundRawEvents, agentsRuntime, agentRuntimeSessions, roomParticipants, unifiedRoomDelivery, roomDisplayNames, computerConnections, computerAgentAssignments, providerIdentityBindings].sort((a, b) => a.version - b.version);
+
+function assertContiguousMigrations(): void {
+  for (let index = 0; index < migrations.length; index += 1) {
+    const expected = index + 1;
+    const actual = migrations[index]!.version;
+    if (actual !== expected) {
+      throw new Error(`migration gap: expected version ${expected}, got ${actual}`);
+    }
+  }
+}
+
+function ensureMigrationsTable(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+function appliedVersions(db: Database): Set<number> {
+  const rows = db.query('SELECT version FROM schema_migrations ORDER BY version ASC').all() as Array<{ version: number }>;
+  return new Set(rows.map((row) => Number(row.version)));
+}
+
+function assertNoMigrationGaps(applied: Set<number>): void {
+  if (applied.size === 0) return;
+  const max = Math.max(...applied);
+  for (let version = 1; version <= max; version += 1) {
+    if (!applied.has(version)) {
+      throw new Error(`MIGRATION_GAP: schema_migrations is missing version ${version}`);
+    }
+  }
+}
+
+function markApplied(db: Database, migration: Migration): void {
+  db.query('INSERT INTO schema_migrations (version, name) VALUES (?, ?)').run(migration.version, migration.name);
+}
+
+export function runMigrations(db: Database): void {
+  assertContiguousMigrations();
+  ensureMigrationsTable(db);
+  const applied = appliedVersions(db);
+  assertNoMigrationGaps(applied);
+
+  for (const migration of migrations) {
+    if (applied.has(migration.version)) continue;
+
+    db.transaction(() => {
+      migration.up(db);
+      markApplied(db, migration);
+    })();
+  }
+}

package/src/neeko.ts

@@ -0,0 +1,23 @@
+import { buildPalPrompt, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+export type { AgentRuntimeRunInput, AgentRuntimeRunResult } from './agent-runtime.js';
+export { runAgentRuntime } from './agent-runtime.js';
+
+export function makeNeekoRuntime(agentUuid: string): AgentRuntime {
+  void agentUuid;
+  return {
+    name: 'neeko',
+    capabilities: { protocol: 'acp', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: true },
+    command: 'neeko',
+    buildPrompt: buildPalPrompt,
+    buildCwd: runtimeCwd,
+    buildArgs(input: AgentRuntimeRunInput): string[] {
+      return ['acp', '--cwd', runtimeCwd(input), ...input.extraArgs];
+    },
+  };
+}
+
+/** @deprecated Use makeNeekoRuntime() + runAgentRuntime() instead. */
+export async function runNeeko(input: AgentRuntimeRunInput): Promise<import('./agent-runtime.js').AgentRuntimeRunResult> {
+  const { runAgentRuntime } = await import('./agent-runtime.js');
+  return runAgentRuntime(makeNeekoRuntime(crypto.randomUUID()), input);
+}

package/src/provider-identity.ts

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+
+export type ProviderExternalType = 'user' | 'bot' | 'room';
+export type PalIdentityKind = ProviderExternalType | 'agent';
+
+const providerNativeIdPattern = /\b(?:ou|oc|om|omt|cli)_[A-Za-z0-9_-]+\b/g;
+
+function hash8(value: string): string {
+  return createHash('sha256').update(value).digest('hex').slice(0, 8);
+}
+
+export function palIdentityHandle(kind: ProviderExternalType, seed: string): string {
+  return `${kind}:pal_${kind}_${hash8(seed)}`;
+}
+
+function providerVirtualHandle(value: string): string {
+  if (value.startsWith('ou_')) return palIdentityHandle('user', value);
+  if (value.startsWith('oc_')) return palIdentityHandle('room', value);
+  if (value.startsWith('cli_')) return `app:pal_app_${hash8(value)}`;
+  if (value.startsWith('om_') || value.startsWith('omt_')) return `message:pal_message_${hash8(value)}`;
+  return virtualizeProviderId(value);
+}
+
+export function virtualizeProviderId(value: string, kind: ProviderExternalType | 'user' = 'user'): string {
+  return palIdentityHandle(kind, value);
+}
+
+export function sanitizeProviderIds(value: string): string {
+  return value.replace(providerNativeIdPattern, (id) => providerVirtualHandle(id));
+}
+
+export function sanitizeProviderIdValue(value: string | null | undefined): string {
+  if (!value) return '';
+  return sanitizeProviderIds(value);
+}
+
+export function containsProviderNativeId(value: string): boolean {
+  providerNativeIdPattern.lastIndex = 0;
+  return providerNativeIdPattern.test(value);
+}

package/src/runtime-registry.ts

@@ -0,0 +1,41 @@
+import type { AgentRuntime, AgentRuntimeProtocol } from './agent-runtime.js';
+
+const supportedProtocols = new Set<AgentRuntimeProtocol>(['json-stream', 'acp']);
+
+const runtimeFactories = {
+  codex: async (agentUuid: string): Promise<AgentRuntime> => {
+    const { makeCodexRuntime } = await import('./codex.js');
+    return makeCodexRuntime(agentUuid);
+  },
+  coco: async (agentUuid: string): Promise<AgentRuntime> => {
+    const { makeCocoRuntime } = await import('./coco.js');
+    return makeCocoRuntime(agentUuid);
+  },
+  'coco-stream-json': async (agentUuid: string): Promise<AgentRuntime> => {
+    const { makeCocoStreamJsonRuntime } = await import('./coco.js');
+    return makeCocoStreamJsonRuntime(agentUuid);
+  },
+  neeko: async (agentUuid: string): Promise<AgentRuntime> => {
+    const { makeNeekoRuntime } = await import('./neeko.js');
+    return makeNeekoRuntime(agentUuid);
+  },
+} satisfies Record<string, (agentUuid: string) => Promise<AgentRuntime>>;
+
+export type RuntimeName = keyof typeof runtimeFactories;
+
+export function knownRuntimeNames(): RuntimeName[] {
+  return Object.keys(runtimeFactories) as RuntimeName[];
+}
+
+export async function resolveRuntimeDriver(runtimeName: string, agentUuid: string): 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);
+  if (!supportedProtocols.has(driver.capabilities.protocol)) {
+    throw new Error(`Runtime '${runtimeName}' uses unsupported protocol '${driver.capabilities.protocol}'. Supported protocols: ${Array.from(supportedProtocols).join(', ')}.`);
+  }
+  return driver;
+}

package/src/server-auth.ts

@@ -0,0 +1,13 @@
+import { defaultServerToken } from './config.js';
+import { HttpError } from './http.js';
+
+export function assertServerAuth(request: Request, token = defaultServerToken()): void {
+  if (!token) throw new HttpError(401, 'UNAUTHORIZED', 'server token is required');
+  if (request.headers.get('authorization') !== `Bearer ${token}`) {
+    throw new HttpError(401, 'UNAUTHORIZED', 'invalid server token');
+  }
+}
+
+export function serverAuthHeaders(token = defaultServerToken()): HeadersInit {
+  return token ? { authorization: `Bearer ${token}` } : {};
+}

package/src/server.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+import { DEFAULT_HOST, DEFAULT_PORT, defaultDbPath } from './config.js';
+import { MessageStore } from './db.js';
+import { handleRequest } from './app.js';
+import { startLarkOnServer } from './lark/server-integration.js';
+
+const dbPath = defaultDbPath();
+const store = new MessageStore(dbPath);
+const port = Number(process.env.PAL_PORT ?? DEFAULT_PORT);
+const host = process.env.PAL_HOST ?? DEFAULT_HOST;
+
+const server = Bun.serve({
+  hostname: host,
+  port,
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (request.method === 'POST' && url.pathname === '/api/lark/reload') {
+      return reloadLarkIntegration();
+    }
+    return handleRequest(store, request);
+  },
+});
+
+console.log(`pal server listening on http://${server.hostname}:${server.port}`);
+console.log(`database: ${dbPath}`);
+
+function startLarkIntegration() {
+  return startLarkOnServer({
+    store,
+    logger: { log: console.log, warn: console.warn, error: console.error },
+  });
+}
+
+// Start Lark bot integration on the server
+let larkIntegration = startLarkIntegration();
+
+async function reloadLarkIntegration(): Promise<Response> {
+  const result = larkIntegration.reload();
+  if (result.ok && larkIntegration.handles.length > 0) {
+    console.log(`[server] lark integrated: ${larkIntegration.handles.map((h) => h.appId).join(',')}`);
+  }
+  return new Response(JSON.stringify(result.ok ? { ok: true, data: result } : { ok: false, error: result.error, data: { bots: result.bots } }), {
+    status: result.ok ? 200 : 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', () => {
+  larkIntegration.stop();
+  server.stop();
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
+  larkIntegration.stop();
+  server.stop();
+  process.exit(0);
+});
+
+// Keep the process alive so the Lark WSClient and HTTP server continue running
+const keepAlive = setInterval(() => {}, 60000);

package/src/token-file.ts

@@ -0,0 +1,57 @@
+import { chmodSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { homeDir } from './config.js';
+
+const TOKEN_BYTES = 32;
+
+function assertPrivateDir(path: string): void {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+  }
+
+  const link = lstatSync(path);
+  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 ((stat.mode & 0o777) !== 0o700) {
+    chmodSync(path, 0o700);
+    const fixed = statSync(path);
+    if ((fixed.mode & 0o777) !== 0o700) throw new Error(`unsafe token directory: ${path} permissions must be 0700`);
+  }
+}
+
+function assertPrivateTokenFile(path: string): 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 ((stat.mode & 0o177) !== 0) throw new Error(`unsafe token file: ${path} permissions must be 0600`);
+}
+
+export function defaultTokenPath(): string {
+  const lockHome = process.env.LOCK_HOME ? resolve(process.env.LOCK_HOME) : resolve(join(homedir(), '.lock'));
+  return resolve(process.env.LOCK_DAEMON_TOKEN_FILE ?? join(lockHome, 'daemon-token'));
+}
+
+export function legacyTokenPath(): string {
+  return join(homeDir(), 'daemon-token');
+}
+
+export function loadOrCreateDaemonToken(path = defaultTokenPath()): string {
+  const resolved = resolve(path);
+  assertPrivateDir(dirname(resolved));
+
+  if (existsSync(resolved)) {
+    assertPrivateTokenFile(resolved);
+    const token = readFileSync(resolved, 'utf8').trim();
+    if (!token) throw new Error(`empty token file: ${resolved}`);
+    return token;
+  }
+
+  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);
+  return token;
+}