@controlflow-ai/daemon 0.1.0

package/src/console.ts

@@ -0,0 +1,349 @@
+#!/usr/bin/env bun
+import { createInterface } from 'node:readline';
+import { boolFlag, parseArgs, flag, numberFlag } from './args.js';
+import { LockClient } from './client.js';
+import { defaultServerUrl } from './config.js';
+import { formatMessages } from './format.js';
+import type { Computer } from './types.js';
+
+interface Prompt {
+  askLine(label: string): Promise<string>;
+  close(): void;
+}
+
+function usage(): string {
+  return `pal console (admin CLI)
+
+Usage:
+  bun run src/console.ts health
+  bun run src/console.ts chats [--json]
+  bun run src/console.ts messages [--chat general] [--parent 1] [--after 0] [--limit 50] [--q text] [--json]
+  bun run src/console.ts inbox --agent neeko [--after 0] [--limit 50] [--json]
+  bun run src/console.ts runs [--json]
+  bun run src/console.ts run-action <run-id> kill|restart
+  bun run src/console.ts agents list [--json]
+  bun run src/console.ts agents onboard [--interactive] [--key <agent-key>] [--name <display-name>] [--runtime codex] [--computer-id <machine>]
+  bun run src/console.ts agents create --key <agent-key> --name <display-name> [--runtime neeko|coco|coco-stream-json|codex] [--desc <description>]
+  bun run src/console.ts agents update --key <agent-key> --runtime neeko|coco|coco-stream-json|codex
+  bun run src/console.ts lark <setup|list|daemon|events|send> [flags]
+
+Environment:
+  PAL_SERVER=${defaultServerUrl()}
+`;
+}
+
+function printJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+async function createPrompt(): Promise<Prompt> {
+  if (process.stdin.isTTY !== true) {
+    const lines = (await Bun.stdin.text()).split(/\r?\n/);
+    return {
+      askLine(label: string) {
+        process.stdout.write(label);
+        return Promise.resolve(lines.shift() ?? '');
+      },
+      close() {},
+    };
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    askLine(label: string) {
+      return new Promise<string>((resolve) => rl.question(label, resolve));
+    },
+    close() {
+      rl.close();
+    },
+  };
+}
+
+async function ask(prompt: Prompt, label: string, defaultValue = ''): Promise<string> {
+  const suffix = defaultValue ? ` [${defaultValue}]` : '';
+  const answer = await prompt.askLine(`${label}${suffix}: `);
+  return answer.trim() || defaultValue;
+}
+
+async function askRequired(prompt: Prompt, label: string, defaultValue = ''): Promise<string> {
+  while (true) {
+    const answer = await ask(prompt, label, defaultValue);
+    if (answer) return answer;
+    console.log(`${label} is required.`);
+  }
+}
+
+async function askRuntime(prompt: Prompt, defaultValue: string): Promise<string> {
+  const runtimes = ['codex', 'neeko', 'coco', 'coco-stream-json'];
+  const fallback = runtimes.includes(defaultValue) ? defaultValue : 'codex';
+  console.log('Runtime:');
+  runtimes.forEach((runtime, index) => {
+    const marker = runtime === fallback ? ' (default)' : '';
+    console.log(`  ${index + 1}. ${runtime}${marker}`);
+  });
+
+  while (true) {
+    const answer = await ask(prompt, 'Choose runtime', fallback);
+    const selected = runtimes[Number(answer) - 1] ?? answer;
+    if (runtimes.includes(selected)) return selected;
+    console.log(`Runtime must be one of: ${runtimes.join(', ')}`);
+  }
+}
+
+async function askYesNo(prompt: Prompt, label: string, defaultValue = false): Promise<boolean> {
+  const fallback = defaultValue ? 'Y/n' : 'y/N';
+  while (true) {
+    const answer = (await ask(prompt, label, fallback)).toLowerCase();
+    if (answer === fallback.toLowerCase()) return defaultValue;
+    if (answer === 'y' || answer === 'yes') return true;
+    if (answer === 'n' || answer === 'no') return false;
+    console.log('Answer yes or no.');
+  }
+}
+
+async function askComputerId(prompt: Prompt, computers: Computer[]): Promise<string> {
+  if (computers.length === 0) {
+    throw new Error('no computers are configured. Set up a computer first in the web UI Provision Computer panel or via POST /api/computers/provision');
+  }
+
+  console.log('Computers:');
+  computers.forEach((computer, index) => {
+    const seen = computer.last_seen_at ? ` last_seen=${computer.last_seen_at}` : '';
+    console.log(`  ${index + 1}. ${computer.name} (${computer.id}) status=${computer.status}${seen}`);
+  });
+
+  while (true) {
+    const answer = await ask(prompt, 'Choose computer', computers.length === 1 ? '1' : '');
+    const selected = computers[Number(answer) - 1] ?? computers.find((computer) => computer.id === answer);
+    if (selected) return selected.id;
+    console.log('Choose a listed number or computer id.');
+  }
+}
+
+async function collectOnboardInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<{ agentKey: string; displayName: string; runtime: string; desc: string | null; computerId: string | undefined }> {
+  const hasRequiredFlags = Boolean(flag(flags, 'key') && flag(flags, 'name'));
+  const interactive = boolFlag(flags, 'interactive') || (!hasRequiredFlags && process.stdin.isTTY === true);
+  if (!interactive) {
+    if (!hasRequiredFlags) throw new Error('agents onboard requires --key and --name when not running interactively');
+    return {
+      agentKey: flag(flags, 'key')!,
+      displayName: flag(flags, 'name')!,
+      runtime: flag(flags, 'runtime') ?? 'codex',
+      desc: flag(flags, 'desc') ?? null,
+      computerId: flag(flags, 'computer-id'),
+    };
+  }
+
+  const prompt = await createPrompt();
+  try {
+    console.log('Agent onboarding');
+    console.log('Create or update a logical agent, optionally assigning it to a computer.');
+    const agentKey = await askRequired(prompt, 'Agent key', flag(flags, 'key') ?? 'codex');
+    const displayName = await askRequired(prompt, 'Display name', flag(flags, 'name') ?? agentKey);
+    const runtime = await askRuntime(prompt, flag(flags, 'runtime') ?? 'codex');
+    const desc = await ask(prompt, 'Description (optional)', flag(flags, 'desc') ?? '');
+    const shouldAssign = Boolean(flag(flags, 'computer-id')) || await askYesNo(prompt, 'Assign this agent to a computer?', false);
+    const computerId = shouldAssign
+      ? flag(flags, 'computer-id') ?? await askComputerId(prompt, await serverClient.listComputers())
+      : '';
+    console.log('');
+    console.log('Summary:');
+    console.log(`  agent_key: ${agentKey}`);
+    console.log(`  display_name: ${displayName}`);
+    console.log(`  runtime: ${runtime}`);
+    console.log(`  description: ${desc || '-'}`);
+    console.log(`  computer_id: ${computerId || '-'}`);
+    if (!await askYesNo(prompt, 'Create/update this agent?', true)) throw new Error('onboarding cancelled');
+    return {
+      agentKey,
+      displayName,
+      runtime,
+      desc: desc || null,
+      computerId: computerId || undefined,
+    };
+  } finally {
+    prompt.close();
+  }
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs();
+  const serverClient = new LockClient(flag(args.flags, 'server'));
+
+  if (args.command === 'help' || args.flags.help) {
+    console.log(usage());
+    return;
+  }
+
+  if (args.command === 'health') {
+    printJson(await serverClient.health());
+    return;
+  }
+
+  if (args.command === 'chats') {
+    const chats = await serverClient.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 === 'runs') {
+    const runs = await serverClient.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 serverClient.requestRunAction(runId, action);
+    printJson(run);
+    return;
+  }
+
+  if (args.command === 'messages') {
+    const params = new URLSearchParams();
+    const chat = flag(args.flags, 'chat');
+    const q = flag(args.flags, 'q');
+    if (chat) params.set('chat', chat);
+    if (q) params.set('q', q);
+    const parent = 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 serverClient.getMessages(params);
+    if (args.flags.json) {
+      printJson(messages);
+    } else {
+      console.log(formatMessages(messages));
+    }
+    return;
+  }
+
+  if (args.command === 'inbox') {
+    const agent = flag(args.flags, 'agent');
+    if (!agent) throw new Error('--agent is required');
+    const messages = await serverClient.getInbox(agent, numberFlag(args.flags, 'after', 0), numberFlag(args.flags, 'limit', 50));
+    if (args.flags.json) {
+      printJson(messages);
+    } else {
+      console.log(formatMessages(messages));
+    }
+    return;
+  }
+
+  if (args.command === 'agents') {
+    const sub = args.values[0];
+
+    if (sub === 'list') {
+      const response = await fetch(`${serverClient.baseUrl}/api/agents`);
+      const payload = await response.json() as { data?: { agents: Array<Record<string, unknown>> }; message?: string };
+      if (!response.ok) throw new Error(payload.message ?? `list failed: ${response.status}`);
+      const agents = payload.data?.agents ?? [];
+      if (args.flags.json) {
+        printJson(agents);
+      } else {
+        for (const agent of agents) {
+          console.log(`${agent.agent_key} name="${agent.display_name}" runtime=${agent.runtime ?? '-'} desc=${agent.description ?? '-'}`);
+        }
+      }
+      return;
+    }
+
+    if (sub === 'create') {
+      const agentKey = flag(args.flags, 'key');
+      const displayName = flag(args.flags, 'name');
+      const runtime = flag(args.flags, 'runtime');
+      const desc = flag(args.flags, 'desc');
+      if (!agentKey) throw new Error('--key is required');
+      if (!displayName) throw new Error('--name is required');
+
+      const response = await fetch(`${serverClient.baseUrl}/api/agents`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          agent_key: agentKey,
+          display_name: displayName,
+          runtime: runtime ?? null,
+          description: desc ?? null,
+        }),
+      });
+      const payload = await response.json() as { data?: { agent: Record<string, unknown> }; message?: string };
+      if (!response.ok) throw new Error(payload.message ?? `create failed: ${response.status}`);
+      printJson(payload.data?.agent);
+      return;
+    }
+
+    if (sub === 'onboard') {
+      const { agentKey, displayName, runtime, desc, computerId } = await collectOnboardInput(serverClient, args.flags);
+      if (!agentKey) throw new Error('agent key is required');
+      if (!displayName) throw new Error('display name is required');
+
+      const response = await fetch(`${serverClient.baseUrl}/api/agents/onboard`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          agent_key: agentKey,
+          display_name: displayName,
+          runtime,
+          description: desc,
+          computer_id: computerId,
+        }),
+      });
+      const payload = await response.json() as { data?: Record<string, unknown>; message?: string };
+      if (!response.ok) throw new Error(payload.message ?? `onboard failed: ${response.status}`);
+      printJson(payload.data);
+      return;
+    }
+
+    if (sub === 'update') {
+      const agentKey = flag(args.flags, 'key');
+      const runtime = flag(args.flags, 'runtime');
+      if (!agentKey) throw new Error('--key is required');
+      if (!runtime) throw new Error('--runtime is required');
+
+      const response = await fetch(`${serverClient.baseUrl}/api/agents/${encodeURIComponent(agentKey)}`, {
+        method: 'PATCH',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ runtime }),
+      });
+      const payload = await response.json() as { data?: { agent: Record<string, unknown> }; message?: string };
+      if (!response.ok) throw new Error(payload.message ?? `update failed: ${response.status}`);
+      printJson(payload.data?.agent);
+      return;
+    }
+
+    throw new Error(`unknown agents subcommand: ${sub ?? '(none)'}\n\n${usage()}`);
+  }
+
+  if (args.command === 'lark') {
+    const { runLarkCli } = await import('./lark/cli.js');
+    const code = await runLarkCli({
+      argv: { command: args.command, values: args.values, flags: args.flags },
+    });
+    if (code !== 0) process.exit(code);
+    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);
+});

package/src/daemon-client.ts

@@ -0,0 +1,91 @@
+import { defaultDaemonToken, defaultDaemonUrl } from './config.js';
+import { localHeaders } from './local-auth.js';
+import type { AgentRoomSubscriptionMode, AgentRun, ApiResponse, Chat, Message, RoomChannel, RoomParticipant, RunAction } from './types.js';
+import type { CreateArtifactRequest, SendRequest } from './client.js';
+
+export class DaemonClient {
+  readonly baseUrl: string;
+  readonly token: string | undefined;
+
+  constructor(baseUrl = defaultDaemonUrl(), token = defaultDaemonToken()) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.token = token;
+  }
+
+  async health(): Promise<{ status: string; mode: string }> {
+    return this.get('/local/health');
+  }
+
+  async sendMessage(input: SendRequest): Promise<Message> {
+    const data = await this.post<{ message: Message }>('/local/messages', input);
+    return data.message;
+  }
+
+  async getMessages(params: URLSearchParams): Promise<Message[]> {
+    const data = await this.get<{ messages: Message[] }>(`/local/messages?${params}`);
+    return data.messages;
+  }
+
+  async listChats(): Promise<Chat[]> {
+    const data = await this.get<{ chats: Chat[] }>('/local/chats');
+    return data.chats;
+  }
+
+  async listRooms(): Promise<Chat[]> {
+    const data = await this.get<{ rooms: Chat[] }>('/local/rooms');
+    return data.rooms;
+  }
+
+  async listRoomMembers(room: string): Promise<{ room: Chat; participants: RoomParticipant[]; completeness: string }> {
+    return this.get<{ room: Chat; participants: RoomParticipant[]; completeness: string }>(`/local/rooms/${encodeURIComponent(room)}/members`);
+  }
+
+  async inviteAgentToRoom(room: string, input: { agent: string; mode?: AgentRoomSubscriptionMode }): Promise<unknown> {
+    return this.post<unknown>(`/local/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 }>(`/local/rooms/${encodeURIComponent(room)}/topics`, input);
+    return data.channel;
+  }
+
+  async getMessage(id: number): Promise<Message> {
+    const data = await this.get<{ message: Message }>(`/local/messages/${id}`);
+    return data.message;
+  }
+
+  async listRuns(): Promise<AgentRun[]> {
+    const data = await this.get<{ runs: AgentRun[] }>('/local/runs');
+    return data.runs;
+  }
+
+  async createArtifact(input: CreateArtifactRequest): Promise<{ artifact: unknown; token: string; url: string }> {
+    return this.post<{ artifact: unknown; token: string; url: string }>('/local/artifacts', input);
+  }
+
+  async requestRunAction(runId: string, action: RunAction): Promise<AgentRun> {
+    const data = await this.post<{ run: AgentRun }>(`/local/runs/${runId}/${action}`, {});
+    return data.run;
+  }
+
+  private async get<T>(path: string): Promise<T> {
+    return this.request<T>(path, { method: 'GET', headers: localHeaders(this.token) });
+  }
+
+  private async post<T>(path: string, body: unknown): Promise<T> {
+    return this.request<T>(path, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...localHeaders(this.token) },
+      body: JSON.stringify(body),
+    });
+  }
+
+  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;
+  }
+}