npm - @controlflow-ai/daemon - Versions diffs - 0.1.0 - Mend

@controlflow-ai/daemon 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/README.md +360 -0
package/bin/console.js +2 -0
package/bin/daemon.js +2 -0
package/bin/pal.js +2 -0
package/bin/server.js +2 -0
package/package.json +31 -0
package/src/agent-runtime.ts +285 -0
package/src/app.ts +745 -0
package/src/args.ts +54 -0
package/src/artifacts.ts +85 -0
package/src/cli.ts +284 -0
package/src/client.ts +310 -0
package/src/coco.ts +52 -0
package/src/codex.ts +41 -0
package/src/coding-agent-runtime.ts +20 -0
package/src/config.ts +106 -0
package/src/console.ts +349 -0
package/src/daemon-client.ts +91 -0
package/src/daemon.ts +580 -0
package/src/db.ts +2830 -0
package/src/failure-message.ts +17 -0
package/src/format.ts +13 -0
package/src/http.ts +55 -0
package/src/lark/agent-runtime.ts +142 -0
package/src/lark/cli.ts +549 -0
package/src/lark/credentials.ts +105 -0
package/src/lark/daemon-integration.ts +108 -0
package/src/lark/dispatcher.ts +374 -0
package/src/lark/event-router.ts +329 -0
package/src/lark/inbound-events.ts +131 -0
package/src/lark/server-integration.ts +445 -0
package/src/lark/setup.ts +326 -0
package/src/lark/ws-daemon.ts +224 -0
package/src/lark-fixture-diagnostics.ts +56 -0
package/src/lark-fixture.ts +277 -0
package/src/local-api.ts +155 -0
package/src/local-auth.ts +45 -0
package/src/migrations/001_initial.ts +61 -0
package/src/migrations/002_daemon_deliveries.ts +52 -0
package/src/migrations/003_sessions_runs.ts +49 -0
package/src/migrations/004_message_idempotency.ts +21 -0
package/src/migrations/005_artifacts.ts +24 -0
package/src/migrations/006_lark_channel_foundation.ts +119 -0
package/src/migrations/007_agents_a0.ts +17 -0
package/src/migrations/008_b0_chat_history.ts +31 -0
package/src/migrations/009_b0_transcript_ingest_seq.ts +35 -0
package/src/migrations/010_b0_transcript_shadow_external_ids.ts +32 -0
package/src/migrations/011_b0_channel_conversation_audit_only.ts +27 -0
package/src/migrations/012_b0_cross_conversation_invariant.ts +45 -0
package/src/migrations/013_b1_0_eng_inbound_raw_events.ts +56 -0
package/src/migrations/014_agents_runtime.ts +10 -0
package/src/migrations/015_agent_runtime_sessions.ts +15 -0
package/src/migrations/016_room_participants.ts +27 -0
package/src/migrations/017_unified_room_delivery.ts +203 -0
package/src/migrations/018_room_display_names.ts +36 -0
package/src/migrations/019_computer_connections.ts +63 -0
package/src/migrations/020_computer_agent_assignments.ts +20 -0
package/src/migrations/021_provider_identity_bindings.ts +32 -0
package/src/migrations.ts +85 -0
package/src/neeko.ts +23 -0
package/src/provider-identity.ts +40 -0
package/src/runtime-registry.ts +41 -0
package/src/server-auth.ts +13 -0
package/src/server.ts +63 -0
package/src/token-file.ts +57 -0
package/src/types.ts +408 -0
package/src/web.ts +565 -0

package/src/args.ts ADDED Viewed

@@ -0,0 +1,54 @@
+export interface ParsedArgs {
+  command: string;
+  values: string[];
+  flags: Record<string, string | boolean>;
+}
+export function parseArgs(argv = process.argv.slice(2)): ParsedArgs {
+  const [command = 'help', ...rest] = argv;
+  const values: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (!arg.startsWith('--')) {
+      values.push(arg);
+      continue;
+    }
+    const raw = arg.slice(2);
+    const eq = raw.indexOf('=');
+    if (eq >= 0) {
+      flags[raw.slice(0, eq)] = raw.slice(eq + 1);
+      continue;
+    }
+    const next = rest[index + 1];
+    if (next && !next.startsWith('--')) {
+      flags[raw] = next;
+      index += 1;
+    } else {
+      flags[raw] = true;
+    }
+  }
+  return { command, values, flags };
+}
+export function flag(flags: Record<string, string | boolean>, name: string, fallback?: string): string | undefined {
+  const value = flags[name];
+  if (typeof value === 'string') return value;
+  return fallback;
+}
+export function boolFlag(flags: Record<string, string | boolean>, name: string): boolean {
+  return flags[name] === true || flags[name] === 'true';
+}
+export function numberFlag(flags: Record<string, string | boolean>, name: string, fallback?: number): number | undefined {
+  const value = flag(flags, name);
+  if (value === undefined) return fallback;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`--${name} must be a number`);
+  return parsed;
+}

package/src/artifacts.ts ADDED Viewed

@@ -0,0 +1,85 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { HttpError } from './http.js';
+export const MAX_ARTIFACT_BYTES = 10 * 1024 * 1024;
+export const DEFAULT_TTL_SECONDS = 24 * 60 * 60;
+export const MAX_TTL_SECONDS = 7 * 24 * 60 * 60;
+const ALLOWED_MIME_TYPES = new Set(['text/html', 'text/plain', 'application/json']);
+export function generateArtifactToken(): string {
+  return randomBytes(32).toString('hex');
+}
+export function hashArtifactToken(token: string): string {
+  return createHash('sha256').update(token).digest('hex');
+}
+export function artifactExpiry(ttlSeconds?: number): string {
+  const ttl = ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  if (!Number.isFinite(ttl) || ttl <= 0) throw new HttpError(400, 'BAD_TTL', 'ttl_seconds must be positive');
+  if (ttl > MAX_TTL_SECONDS) throw new HttpError(400, 'TTL_TOO_LONG', 'ttl_seconds exceeds maximum');
+  return new Date(Date.now() + ttl * 1000).toISOString();
+}
+function looksLikeSvg(content: Uint8Array): boolean {
+  const prefix = new TextDecoder().decode(content.slice(0, Math.min(content.length, 512))).trimStart().toLowerCase();
+  return prefix.startsWith('<svg') || prefix.includes('<svg ');
+}
+function looksLikeHtml(content: Uint8Array): boolean {
+  const prefix = new TextDecoder().decode(content.slice(0, Math.min(content.length, 512))).trimStart().toLowerCase();
+  return prefix.startsWith('<!doctype html') || prefix.startsWith('<html') || prefix.includes('<script') || prefix.includes('<body');
+}
+function looksLikeJson(content: Uint8Array): boolean {
+  const value = new TextDecoder().decode(content).trim();
+  if (!value) return false;
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function validateArtifactContent(mimeType: string, content: Uint8Array): void {
+  if (!ALLOWED_MIME_TYPES.has(mimeType)) throw new HttpError(400, 'UNSUPPORTED_MIME', 'unsupported artifact MIME type');
+  if (content.length === 0) throw new HttpError(400, 'EMPTY_ARTIFACT', 'artifact content is required');
+  if (content.length > MAX_ARTIFACT_BYTES) throw new HttpError(400, 'ARTIFACT_TOO_LARGE', 'artifact exceeds size limit');
+  if (looksLikeSvg(content)) throw new HttpError(400, 'SVG_NOT_SUPPORTED', 'SVG artifacts are not supported');
+  if (mimeType === 'application/json' && !looksLikeJson(content)) {
+    throw new HttpError(400, 'MIME_CONFLICT', 'declared JSON artifact is not valid JSON');
+  }
+  if (mimeType === 'text/plain' && looksLikeHtml(content)) {
+    throw new HttpError(400, 'MIME_CONFLICT', 'HTML content must be declared as text/html');
+  }
+}
+export function artifactHeaders(): HeadersInit {
+  return {
+    'content-type': 'text/html; charset=utf-8',
+    'content-security-policy': "sandbox allow-scripts; default-src 'none'; script-src 'none'; connect-src 'none'; img-src data: blob:; style-src 'none'; form-action 'none'; base-uri 'none'; frame-ancestors 'none'",
+    'x-content-type-options': 'nosniff',
+    'referrer-policy': 'no-referrer',
+    'cache-control': 'private, no-store',
+  };
+}
+function escapeHtml(value: string): string {
+  return value.replace(/[&<>"']/g, (char) => ({
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+  }[char]!));
+}
+export function artifactViewerHtml(content: Uint8Array, mimeType: string): string {
+  const text = new TextDecoder().decode(content);
+  const srcdoc = mimeType === 'text/html' ? text : `<pre>${escapeHtml(text)}</pre>`;
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Artifact</title><style>html,body,iframe{width:100%;height:100%;margin:0;border:0}</style></head><body><iframe sandbox="allow-scripts" referrerpolicy="no-referrer" srcdoc="${escapeHtml(srcdoc)}"></iframe></body></html>`;
+}

package/src/cli.ts ADDED Viewed

@@ -0,0 +1,284 @@
+#!/usr/bin/env bun
+import { readFileSync, statSync } from 'node:fs';
+import { parseArgs, flag, numberFlag } from './args.js';
+import { DaemonClient } from './daemon-client.js';
+import { defaultDaemonUrl } from './config.js';
+import { formatMessages } from './format.js';
+import { sanitizeProviderIds } from './provider-identity.js';
+function usage(): string {
+  return `pal cli (agent CLI)
+Usage:
+  bun run src/cli.ts send --room general --from alice [--to codex] [--channel <channel-id>] <message>
+  bun run src/cli.ts topics create --room general <name>
+  bun run src/cli.ts rooms invite --room general --agent codex [--mode mentions|all|periodic|muted|off]
+  bun run src/cli.ts debate start --chat general --a palbeta --b clawed [--turns 6] <topic>
+  bun run src/cli.ts rooms list [--json]
+  bun run src/cli.ts rooms members --room <room-id-or-name> [--json]
+  bun run src/cli.ts messages list [--room general] [--topic 1] [--after 0] [--limit 50] [--q text] [--json]
+  bun run src/cli.ts messages show <message-id> [--json]
+  bun run src/cli.ts runs [--json]
+  bun run src/cli.ts run-action <run-id> kill|restart
+  bun run src/cli.ts chats [--json]
+  bun run src/cli.ts health
+  bun run src/cli.ts http file <path> [--mime <type>] [--title <title>] [--ttl <seconds>]
+Environment:
+  LOCK_DAEMON_URL=${defaultDaemonUrl()}
+  LOCK_DAEMON_TOKEN=<token>
+`;
+}
+async function readStdin(): Promise<string> {
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+function positionalContent(values: string[]): string {
+  return values.join(' ').trim();
+}
+function printJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+function looksLikeId(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function buildDebateOpening(input: { topic: string; firstAgent: string; secondAgent: string; turns: number; chat: string }): string {
+  return [
+    'Start an agent-to-agent debate in this room.',
+    `Debate topic: ${input.topic}`,
+    `Participants: @${input.firstAgent} and @${input.secondAgent}.`,
+    `Turn budget: ${input.turns} total agent turns.`,
+    `You are @${input.firstAgent}. Make the first argument, then send the next turn to @${input.secondAgent} with: bun run src/cli.ts send --chat ${input.chat} --from ${input.firstAgent} --to ${input.secondAgent} <message>`,
+    `Every later turn should address the other agent with --to so their daemon runtime is triggered. Stop naturally when the turn budget is reached.`,
+  ].join('\n');
+}
+async function main(): Promise<void> {
+  const args = parseArgs();
+  const daemonClient = new DaemonClient(flag(args.flags, 'daemon'));
+  if (args.command === 'help' || args.flags.help) {
+    console.log(usage());
+    return;
+  }
+  if (args.command === 'health') {
+    printJson(await daemonClient.health());
+    return;
+  }
+  if (args.command === 'chats') {
+    const chats = await daemonClient.listChats();
+    if (args.flags.json) {
+      printJson(chats);
+    } else {
+      for (const chat of chats) {
+        console.log(`#${chat.name} messages=${chat.message_count} last=${chat.last_message_at ?? '-'}`);
+      }
+    }
+    return;
+  }
+  if (args.command === 'rooms') {
+    const sub = args.values[0] ?? 'list';
+    if (sub === 'list') {
+      const rooms = await daemonClient.listRooms();
+      if (args.flags.json) {
+        printJson(rooms);
+      } else {
+        for (const room of rooms) {
+          console.log(`${room.id} #${room.name} kind=${room.kind} messages=${room.message_count} last=${room.last_message_at ?? '-'}`);
+        }
+      }
+      return;
+    }
+    if (sub === 'invite') {
+      const roomRef = flag(args.flags, 'room') ?? args.values[1];
+      const agent = flag(args.flags, 'agent') ?? args.values[2];
+      if (!roomRef) throw new Error('rooms invite requires --room <room-id-or-name>');
+      if (!agent) throw new Error('rooms invite requires --agent <agent-key>');
+      const result = await daemonClient.inviteAgentToRoom(roomRef, { agent, mode: flag(args.flags, 'mode') as never });
+      printJson(result);
+      return;
+    }
+    if (sub === 'members') {
+      const roomRef = flag(args.flags, 'room') ?? args.values[1];
+      if (!roomRef) throw new Error('rooms members requires --room <room-id-or-name>');
+      const result = await daemonClient.listRoomMembers(roomRef);
+      if (args.flags.json) {
+        printJson(result);
+      } else {
+        console.log(`#${result.room.name} (${result.room.id})`);
+        for (const participant of result.participants) {
+          const name = participant.display_name ? ` ${sanitizeProviderIds(participant.display_name)}` : '';
+          console.log(`${participant.kind.padEnd(5)} ${sanitizeProviderIds(participant.participant_id)}${name} source=${participant.source} last=${participant.last_seen_at}`);
+        }
+        console.log(`completeness: ${result.completeness}`);
+      }
+      return;
+    }
+    throw new Error(`unknown rooms subcommand: ${sub}`);
+  }
+  if (args.command === 'runs') {
+    const runs = await daemonClient.listRuns();
+    if (args.flags.json) {
+      printJson(runs);
+    } else {
+      for (const run of runs) {
+        console.log(`${run.id} status=${run.status} agent=${run.agent} message=${run.message_id} attempt=${run.attempt} pid=${run.pid ?? '-'}`);
+      }
+    }
+    return;
+  }
+  if (args.command === 'run-action') {
+    const [runId, action] = args.values;
+    if (!runId) throw new Error('run id is required');
+    if (action !== 'kill' && action !== 'restart') throw new Error('action must be kill or restart');
+    const run = await daemonClient.requestRunAction(runId, action);
+    printJson(run);
+    return;
+  }
+  if (args.command === 'debate') {
+    const sub = args.values[0];
+    if (sub !== 'start') throw new Error('usage: debate start --chat <room> --a <agent> --b <agent> [--turns N] <topic>');
+    const firstAgent = flag(args.flags, 'a') ?? flag(args.flags, 'agent-a');
+    const secondAgent = flag(args.flags, 'b') ?? flag(args.flags, 'agent-b');
+    const chat = flag(args.flags, 'chat') ?? 'general';
+    const turns = numberFlag(args.flags, 'turns', 6)!;
+    const topic = args.values.slice(1).join(' ').trim() || flag(args.flags, 'topic');
+    if (!firstAgent) throw new Error('debate start requires --a <agent>');
+    if (!secondAgent) throw new Error('debate start requires --b <agent>');
+    if (firstAgent === secondAgent) throw new Error('debate agents must be different');
+    if (!Number.isInteger(turns) || turns < 2) throw new Error('debate --turns must be an integer >= 2');
+    if (!topic) throw new Error('debate start requires a topic');
+    const message = await daemonClient.sendMessage({
+      chat,
+      sender: 'debate',
+      recipient: firstAgent,
+      content: buildDebateOpening({ topic, firstAgent, secondAgent, turns, chat }),
+    });
+    if (args.flags.json) {
+      printJson(message);
+    } else {
+      console.log(formatMessages([message]));
+    }
+    return;
+  }
+  if (args.command === 'topics') {
+    const sub = args.values[0];
+    if (sub !== 'create') throw new Error('usage: topics create --room <room> <name>');
+    const room = flag(args.flags, 'room');
+    const name = args.values.slice(1).join(' ').trim() || flag(args.flags, 'name');
+    if (!room) throw new Error('topics create requires --room <room>');
+    if (!name) throw new Error('topics create requires a topic name');
+    const channel = await daemonClient.createTopic(room, { name, created_by: flag(args.flags, 'from') ?? flag(args.flags, 'sender') ?? process.env.USER ?? 'human' });
+    if (args.flags.json) printJson(channel);
+    else console.log(`${channel.id} topic=${channel.name} room=${channel.room_id}`);
+    return;
+  }
+  if (args.command === 'http') {
+    const [kind, filePath] = args.values;
+    if (kind !== 'file') throw new Error('usage: http file <path>');
+    if (!filePath) throw new Error('file path is required');
+    const stat = statSync(filePath);
+    if (!stat.isFile()) throw new Error('path must be a file');
+    const bytes = readFileSync(filePath);
+    const mimeType = flag(args.flags, 'mime') ?? (filePath.endsWith('.html') ? 'text/html' : 'text/plain');
+    const artifact = await daemonClient.createArtifact({
+      content_base64: Buffer.from(bytes).toString('base64'),
+      mime_type: mimeType,
+      filename: filePath.split('/').pop(),
+      title: flag(args.flags, 'title'),
+      ttl_seconds: numberFlag(args.flags, 'ttl'),
+    });
+    printJson(artifact);
+    return;
+  }
+  if (args.command === 'send') {
+    const file = flag(args.flags, 'file');
+    const inlineContent = positionalContent(args.values);
+    const fileContent = !inlineContent && file ? readFileSync(file, 'utf8').trim() : '';
+    const stdinContent = !inlineContent && !fileContent && !process.stdin.isTTY ? (await readStdin()).trim() : '';
+    const content = inlineContent || fileContent || stdinContent;
+    const sender = flag(args.flags, 'from') ?? flag(args.flags, 'sender') ?? process.env.USER ?? 'human';
+    if (!content) throw new Error('message content is required');
+    const message = await daemonClient.sendMessage({
+      chat: flag(args.flags, 'room') ?? flag(args.flags, 'chat') ?? 'general',
+      room: flag(args.flags, 'room'),
+      parent_id: numberFlag(args.flags, 'parent'),
+      channel_id: flag(args.flags, 'channel') ?? flag(args.flags, 'channel-id') ?? null,
+      sender,
+      recipient: flag(args.flags, 'to') ?? flag(args.flags, 'recipient'),
+      content,
+    });
+    if (args.flags.json) {
+      printJson(message);
+    } else {
+      console.log(formatMessages([message]));
+    }
+    return;
+  }
+  if (args.command === 'messages') {
+    const sub = args.values[0];
+    if (sub === 'show') {
+      const id = Number(args.values[1]);
+      if (!Number.isFinite(id)) throw new Error('messages show requires <message-id>');
+      const message = await daemonClient.getMessage(id);
+      if (args.flags.json) {
+        printJson(message);
+      } else {
+        console.log(formatMessages([message]));
+      }
+      return;
+    }
+    const params = new URLSearchParams();
+    const room = flag(args.flags, 'room');
+    const chat = flag(args.flags, 'chat') ?? (room && !looksLikeId(room) ? room : undefined);
+    const chatId = flag(args.flags, 'chat-id') ?? (room && looksLikeId(room) ? room : undefined);
+    const q = flag(args.flags, 'q');
+    if (chat) params.set('chat', chat);
+    if (chatId) params.set('chat_id', chatId);
+    if (q) params.set('q', q);
+    const parent = numberFlag(args.flags, 'topic') ?? numberFlag(args.flags, 'parent');
+    const after = numberFlag(args.flags, 'after');
+    const limit = numberFlag(args.flags, 'limit', 50);
+    if (parent !== undefined) params.set('parent_id', String(parent));
+    if (after !== undefined) params.set('after', String(after));
+    if (limit !== undefined) params.set('limit', String(limit));
+    const messages = await daemonClient.getMessages(params);
+    if (args.flags.json) {
+      printJson(messages);
+    } else {
+      console.log(formatMessages(messages));
+    }
+    return;
+  }
+  throw new Error(`unknown command: ${args.command}\n\n${usage()}`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});