@controlflow-ai/daemon 0.1.1 → 0.1.3

package/src/console.ts

@@ -4,7 +4,12 @@ import { boolFlag, parseArgs, flag, numberFlag } from './args.js';
 import { LockClient } from './client.js';
 import { defaultServerUrl } from './config.js';
 import { formatMessages } from './format.js';
+import { defaultLarkConfigPath, findCredentialByAgent, loadLarkCredentials, saveLarkCredentials, unbindCredentialAgent, upsertCredential } from './lark/credentials.js';
+import { registerLarkAppFromDeviceFlow, resolveLarkBotInfo, type LarkBotInfoResult } from './lark/setup.js';
+import { runtimeModelOptions, validateRuntimeModel } from './runtime-registry.js';
+import type { LarkRegistrationComplete } from './lark/app-registration.js';
 import type { Computer, ProvisionedComputer } from './types.js';
+import { runMessagingCommand } from './messaging-cli.js';
 
 interface Prompt {
   askLine(label: string): Promise<string>;
@@ -23,14 +28,28 @@ Usage:
   bun run src/console.ts run-action <run-id> kill|restart
   bun run src/console.ts computers list [--json]
   bun run src/console.ts computer onboard [--interactive] [--name <display-name>] [--server-url <url>] [--package-name <npm-package>]
+  bun run src/console.ts computers reconnect-command [--interactive] [--computer-id <machine>] [--server-url <url>] [--package-name <npm-package>] [--json]
+  bun run src/console.ts computers delete [--interactive] [--computer-id <machine>] [--json]
   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 agents onboard [--interactive] [--key <agent-key>] [--name <display-name>] [--runtime codex] [--model <model>] [--computer-id <machine>]
+  bun run src/console.ts agents create --key <agent-key> --name <display-name> [--runtime neeko|coco|codex] [--model <model>] [--desc <description>]
+  bun run src/console.ts agents update [--interactive] --key <agent-key> [--runtime neeko|coco|codex] [--model <model>]
+      [--lark-app-id <id> --lark-app-secret <secret>] [--lark-label <name>] [--lark-config <path>] [--rebind-lark] [--unbind-lark] [--no-reload]
+  bun run src/console.ts agents delete --key <agent-key> [--yes] [--lark-config <path>] [--no-reload] [--json]
   bun run src/console.ts lark-users list [--json]
   bun run src/console.ts lark-users add [--interactive] --user-id <union-id> [--name <display-name>]
   bun run src/console.ts lark-users delete --user-id <union-id>
-  bun run src/console.ts lark <setup|list|daemon|events|send> [flags]
+  bun run src/console.ts messaging health [--json]
+  bun run src/console.ts messaging status [--verbose] [--json]
+  bun run src/console.ts messaging restart-lark [--app-id <id>] [--json]
+  bun run src/console.ts messaging repair-lark [--dry-run] [--json]
+  bun run src/console.ts messaging doctor-lark [--app-id <id>] [--config <path>] [--budget-ms 10000] [--json]
+  bun run src/console.ts messaging watch-lark [--app-id <id>] [--timeout-ms 60000] [--interval-ms 1000] [--json]
+  bun run src/console.ts messaging verify-lark-ingress [--app-id <id>] [--timeout-ms 60000] [--interval-ms 1000] [--json]
+  bun run src/console.ts messaging recent-lark [--limit 20] [--json]
+  bun run src/console.ts messaging probe-lark --app-id <id> --sender-user-id <union-id> --chat-id <chat-id> [--mention-open-id <open-id>] [--text <message>] [--json]
+  bun run src/console.ts messaging probe-delivery [--agent lock] [--room <room>] [--timeout-ms 120000] [--json]
+  bun run src/console.ts lark <list|daemon|events|send> [flags]
 
 Environment:
   PAL_SERVER=${defaultServerUrl()}
@@ -44,6 +63,83 @@ async function requestJson<T>(url: string, init?: RequestInit): Promise<T> {
   return payload.data as T;
 }
 
+async function reloadLarkIntegration(serverUrl: string): Promise<void> {
+  const response = await fetch(`${serverUrl.replace(/\/$/, '')}/api/lark/reload`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({}),
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    console.warn(`Lark bot config saved, but server reload failed (${response.status}): ${text}`);
+    return;
+  }
+  console.log('Lark integration reloaded.');
+}
+
+async function resolveBotInfoForConsole(appId: string, appSecret: string, options: { budgetMs?: number } = {}): Promise<LarkBotInfoResult> {
+  if (process.env.NODE_ENV === 'test' && process.env.PAL_TEST_LARK_BOT_OPEN_ID) {
+    return { ok: true, openId: process.env.PAL_TEST_LARK_BOT_OPEN_ID };
+  }
+  return resolveLarkBotInfo(appId, appSecret, options);
+}
+
+async function registerLarkAppForConsole(): Promise<LarkRegistrationComplete | null> {
+  if (process.env.NODE_ENV === 'test' && process.env.PAL_TEST_LARK_REGISTRATION_APP_ID && process.env.PAL_TEST_LARK_REGISTRATION_APP_SECRET) {
+    console.log('Create a Feishu app by scanning this QR code or opening the link:');
+    console.log('https://example.test/lark-registration');
+    return {
+      appId: process.env.PAL_TEST_LARK_REGISTRATION_APP_ID,
+      appSecret: process.env.PAL_TEST_LARK_REGISTRATION_APP_SECRET,
+      tenantBrand: 'feishu',
+      userOpenId: process.env.PAL_TEST_LARK_REGISTRATION_USER_OPEN_ID,
+    };
+  }
+  return registerLarkAppFromDeviceFlow({ log: console });
+}
+
+function larkConfigPath(flags: Record<string, string | boolean>): string {
+  return flag(flags, 'lark-config') ?? flag(flags, 'config') ?? defaultLarkConfigPath();
+}
+
+async function unbindLarkBotFromAgent(serverClient: LockClient, flags: Record<string, string | boolean>, agentKey: string): Promise<void> {
+  const configPath = larkConfigPath(flags);
+  const store = loadLarkCredentials(configPath);
+  const result = unbindCredentialAgent(store, agentKey);
+  if (!result.changed) {
+    console.log(`Agent ${agentKey} has no Lark bot binding.`);
+    return;
+  }
+  saveLarkCredentials(result.store, configPath);
+  console.log(`Lark bot ${result.unbound!.appId} unbound from agent ${agentKey}.`);
+  if (!boolFlag(flags, 'no-reload')) await reloadLarkIntegration(serverClient.baseUrl);
+}
+
+async function bindLarkBotToAgent(serverClient: LockClient, flags: Record<string, string | boolean>, agentKey: string): Promise<void> {
+  const appId = flag(flags, 'lark-app-id') ?? flag(flags, 'app-id');
+  const appSecret = flag(flags, 'lark-app-secret') ?? flag(flags, 'app-secret');
+  if (!appId && !appSecret) return;
+  if (!appId || !appSecret) throw new Error('--lark-app-id and --lark-app-secret are required together');
+
+  const botInfo = await resolveBotInfoForConsole(appId, appSecret);
+  if (!botInfo.ok) throw new Error(`could not resolve Lark bot open_id (${botInfo.error}): ${botInfo.message}`);
+
+  const configPath = larkConfigPath(flags);
+  const store = loadLarkCredentials(configPath);
+  const result = upsertCredential(store, {
+    appId,
+    appSecret,
+    label: flag(flags, 'lark-label') ?? flag(flags, 'label'),
+    agent: agentKey,
+    botOpenId: botInfo.openId,
+  }, { rebind: boolFlag(flags, 'rebind-lark') });
+  saveLarkCredentials(result.store, configPath);
+
+  const moved = result.unbound.length > 0 ? `; moved from ${result.unbound.map((bot) => bot.appId).join(', ')}` : '';
+  console.log(`Lark bot ${appId} bound to agent ${agentKey}${moved}.`);
+  if (!boolFlag(flags, 'no-reload')) await reloadLarkIntegration(serverClient.baseUrl);
+}
+
 function printJson(value: unknown): void {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -86,7 +182,7 @@ async function askRequired(prompt: Prompt, label: string, defaultValue = ''): Pr
 }
 
 async function askRuntime(prompt: Prompt, defaultValue: string): Promise<string> {
-  const runtimes = ['codex', 'neeko', 'coco', 'coco-stream-json'];
+  const runtimes = ['codex', 'neeko', 'coco'];
   const fallback = runtimes.includes(defaultValue) ? defaultValue : 'codex';
   console.log('Runtime:');
   runtimes.forEach((runtime, index) => {
@@ -102,6 +198,29 @@ async function askRuntime(prompt: Prompt, defaultValue: string): Promise<string>
   }
 }
 
+async function askModel(prompt: Prompt, runtime: string, defaultValue = ''): Promise<string> {
+  const models = await runtimeModelOptions(runtime);
+  if (models.length === 0) {
+    console.log(`Model: ${runtime} has no built-in model list; using runtime default.`);
+    return '';
+  }
+  const fallback = models.includes(defaultValue) ? defaultValue : models[0]!;
+  console.log('Model:');
+  console.log('  0. Runtime default');
+  models.forEach((model, index) => {
+    const marker = model === fallback ? ' (default)' : '';
+    console.log(`  ${index + 1}. ${model}${marker}`);
+  });
+
+  while (true) {
+    const answer = await ask(prompt, `Choose ${runtime} model`, fallback);
+    if (answer === '0') return '';
+    const selected = models[Number(answer) - 1] ?? answer;
+    if (models.includes(selected)) return selected;
+    console.log(`Model must be one of: ${models.join(', ')}`);
+  }
+}
+
 async function askYesNo(prompt: Prompt, label: string, defaultValue = false): Promise<boolean> {
   const fallback = defaultValue ? 'Y/n' : 'y/N';
   while (true) {
@@ -132,12 +251,35 @@ async function askComputerId(prompt: Prompt, computers: Computer[]): Promise<str
   }
 }
 
+async function listAgentRecords(serverClient: LockClient): Promise<Array<Record<string, unknown>>> {
+  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}`);
+  return payload.data?.agents ?? [];
+}
+
+async function askAgentKey(prompt: Prompt, agents: Array<Record<string, unknown>>, defaultValue = ''): Promise<string> {
+  if (agents.length === 0) throw new Error('No agents found. Set up an agent first with "bun run console -- agents onboard".');
+
+  console.log('Agents:');
+  agents.forEach((agent, index) => {
+    console.log(`  ${index + 1}. ${agent.display_name} (${agent.agent_key}) runtime=${agent.runtime ?? '-'}`);
+  });
+
+  while (true) {
+    const answer = await ask(prompt, 'Choose agent', defaultValue);
+    const selected = agents[Number(answer) - 1] ?? agents.find((agent) => agent.agent_key === answer);
+    if (selected?.agent_key) return String(selected.agent_key);
+    console.log('Choose a listed number or agent key.');
+  }
+}
+
 async function collectComputerOnboardInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<{ name: string; serverUrl: string; packageName: string }> {
   const hasAnyProvisionFlag = Boolean(flag(flags, 'name') || flag(flags, 'server-url') || flag(flags, 'package-name'));
   const interactive = boolFlag(flags, 'interactive') || (!hasAnyProvisionFlag && process.stdin.isTTY === true);
   const defaultName = flag(flags, 'name') ?? 'Local computer';
   const defaultServerUrl = flag(flags, 'server-url') ?? serverClient.baseUrl;
-  const defaultPackageName = flag(flags, 'package-name') ?? '@slock-ai/daemon@latest';
+  const defaultPackageName = flag(flags, 'package-name') ?? 'bun run daemon';
 
   if (!interactive) {
     return {
@@ -153,12 +295,12 @@ async function collectComputerOnboardInput(serverClient: LockClient, flags: Reco
     console.log('Provision a computer credential and daemon start command.');
     const name = await askRequired(prompt, 'Computer display name', defaultName);
     const serverUrl = await askRequired(prompt, 'Server URL', defaultServerUrl);
-    const packageName = await askRequired(prompt, 'Daemon package', defaultPackageName);
+    const packageName = await askRequired(prompt, 'Daemon command/package', defaultPackageName);
     console.log('');
     console.log('Summary:');
     console.log(`  name: ${name}`);
     console.log(`  server_url: ${serverUrl}`);
-    console.log(`  package_name: ${packageName}`);
+    console.log(`  command_prefix: ${packageName}`);
     if (!await askYesNo(prompt, 'Provision this computer?', true)) throw new Error('computer onboarding cancelled');
     return { name, serverUrl, packageName };
   } finally {
@@ -176,7 +318,56 @@ function printProvisionedComputer(provisioned: ProvisionedComputer): void {
   console.log(provisioned.command);
 }
 
-async function collectOnboardInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<{ agentKey: string; displayName: string; runtime: string; desc: string | null; computerId: string | undefined }> {
+async function collectLarkBindFlags(prompt: Prompt, flags: Record<string, string | boolean>, agentKey: string, existingAppId?: string): Promise<Record<string, string | boolean>> {
+  const configPath = larkConfigPath(flags);
+  console.log('Lark bot setup');
+  console.log('  1. Scan or open link to create app');
+  console.log('  2. Paste App ID / App Secret');
+  const method = await ask(prompt, 'Setup method', '1');
+
+  let appId = flag(flags, 'lark-app-id') ?? flag(flags, 'app-id');
+  let appSecret = flag(flags, 'lark-app-secret') ?? flag(flags, 'app-secret');
+  let scannedUserOpenId: string | undefined;
+  if (method !== '2' && (!appId || !appSecret)) {
+    const registration = await registerLarkAppForConsole().catch((error) => {
+      console.warn(`App registration failed: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    });
+    if (registration?.tenantBrand === 'lark') {
+      throw new Error('Lark international tenants are not supported yet; use a Feishu tenant');
+    }
+    if (registration) {
+      appId = registration.appId;
+      appSecret = registration.appSecret;
+      scannedUserOpenId = registration.userOpenId;
+      console.log(`App created: ${appId}`);
+    } else {
+      console.warn('Falling back to manual App ID / App Secret entry.');
+    }
+  }
+
+  appId = appId || await askRequired(prompt, 'Lark App ID', existingAppId ?? '');
+  appSecret = appSecret || await askRequired(prompt, 'Lark App Secret');
+  const label = await ask(prompt, 'Bot label (optional)', flag(flags, 'lark-label') ?? flag(flags, 'label') ?? '');
+  if (scannedUserOpenId) {
+    console.log(`Scanner open_id ${scannedUserOpenId} was detected; add it under Lark authorized users if this user should operate Pal.`);
+  }
+
+  const isChangingBot = Boolean(existingAppId && existingAppId !== appId);
+  const rebind = boolFlag(flags, 'rebind-lark') || (isChangingBot && await askYesNo(prompt, `Move ${agentKey} from ${existingAppId} to ${appId}?`, false));
+  if (isChangingBot && !rebind) throw new Error('Lark bot rebind cancelled');
+
+  return {
+    ...flags,
+    'lark-app-id': appId,
+    'lark-app-secret': appSecret,
+    'lark-config': configPath,
+    ...(label ? { 'lark-label': label } : {}),
+    ...(rebind ? { 'rebind-lark': true } : {}),
+  };
+}
+
+async function collectOnboardInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<{ agentKey: string; displayName: string; runtime: string; model: string | null; desc: string | null; computerId: string | undefined; larkFlags?: Record<string, string | boolean> }> {
   const hasRequiredFlags = Boolean(flag(flags, 'key') && flag(flags, 'name'));
   const interactive = boolFlag(flags, 'interactive') || (!hasRequiredFlags && process.stdin.isTTY === true);
   if (!interactive) {
@@ -185,8 +376,10 @@ async function collectOnboardInput(serverClient: LockClient, flags: Record<strin
       agentKey: flag(flags, 'key')!,
       displayName: flag(flags, 'name')!,
       runtime: flag(flags, 'runtime') ?? 'codex',
+      model: await validateRuntimeModel(flag(flags, 'runtime') ?? 'codex', flag(flags, 'model')),
       desc: flag(flags, 'desc') ?? null,
       computerId: flag(flags, 'computer-id'),
+      larkFlags: flag(flags, 'lark-app-id') || flag(flags, 'app-id') ? flags : undefined,
     };
   }
 
@@ -197,6 +390,7 @@ async function collectOnboardInput(serverClient: LockClient, flags: Record<strin
     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 model = await askModel(prompt, runtime, flag(flags, 'model') ?? '');
     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
@@ -207,21 +401,152 @@ async function collectOnboardInput(serverClient: LockClient, flags: Record<strin
     console.log(`  agent_key: ${agentKey}`);
     console.log(`  display_name: ${displayName}`);
     console.log(`  runtime: ${runtime}`);
+    console.log(`  model: ${model || '-'}`);
     console.log(`  description: ${desc || '-'}`);
     console.log(`  computer_id: ${computerId || '-'}`);
     if (!await askYesNo(prompt, 'Create/update this agent?', true)) throw new Error('onboarding cancelled');
+    const shouldSetupLark = await askYesNo(prompt, 'Set up a Lark bot for this agent?', false);
+    const larkFlags = shouldSetupLark ? await collectLarkBindFlags(prompt, flags, agentKey) : undefined;
     return {
       agentKey,
       displayName,
       runtime,
+      model: model || null,
       desc: desc || null,
       computerId: computerId || undefined,
+      larkFlags,
+    };
+  } finally {
+    prompt.close();
+  }
+}
+
+async function collectAgentUpdateInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<{ agentKey: string; flags: Record<string, string | boolean> }> {
+  const prompt = await createPrompt();
+  try {
+    console.log('Agent settings');
+    const agents = await listAgentRecords(serverClient);
+    const agentKey = await askAgentKey(prompt, agents, flag(flags, 'key') ?? (agents.length === 1 ? '1' : ''));
+    const agent = agents.find((candidate) => candidate.agent_key === agentKey);
+    if (!agent) throw new Error(`agent ${agentKey} not found`);
+
+    if (flag(flags, 'model')) return { agentKey, flags };
+
+    const requestedLarkUpdate = Boolean(
+      boolFlag(flags, 'unbind-lark') ||
+      flag(flags, 'lark-app-id') ||
+      flag(flags, 'app-id') ||
+      flag(flags, 'lark-app-secret') ||
+      flag(flags, 'app-secret'),
+    );
+    let updateAction = requestedLarkUpdate ? (boolFlag(flags, 'unbind-lark') ? '3' : '2') : '';
+    if (!updateAction) {
+      console.log('Update:');
+      console.log('  1. Model');
+      console.log('  2. Bind/rebind Lark bot');
+      console.log('  3. Unbind Lark bot');
+      updateAction = await ask(prompt, 'Choose update', '1');
+    }
+
+    if (updateAction === '1' || updateAction.toLowerCase() === 'model') {
+      const runtime = typeof agent.runtime === 'string' ? agent.runtime : '';
+      if (!runtime) throw new Error(`agent ${agentKey} has no runtime configured`);
+      const model = await askModel(prompt, runtime, typeof agent.model === 'string' ? agent.model : '');
+      console.log('');
+      console.log('Summary:');
+      console.log(`  agent_key: ${agentKey}`);
+      console.log(`  runtime: ${runtime}`);
+      console.log(`  model: ${model || '-'}`);
+      if (!await askYesNo(prompt, 'Update this agent model?', true)) throw new Error('agent update cancelled');
+      return { agentKey, flags: { ...flags, model } };
+    }
+
+    if (updateAction !== '2' && updateAction !== '3') throw new Error('Choose 1, 2, or 3.');
+
+    const configPath = larkConfigPath(flags);
+    const store = loadLarkCredentials(configPath);
+    const existing = findCredentialByAgent(store, agentKey);
+    if (existing) {
+      console.log(`Current Lark bot: ${existing.label ?? existing.appId} (${existing.appId})`);
+    } else {
+      console.log('Current Lark bot: -');
+    }
+
+    if (updateAction === '3') {
+      if (!existing) throw new Error(`agent ${agentKey} has no Lark bot binding`);
+      if (!await askYesNo(prompt, `Unbind ${existing.appId} from ${agentKey}?`, false)) throw new Error('Lark bot unbind cancelled');
+      return {
+        agentKey,
+        flags: {
+          ...flags,
+          'lark-config': configPath,
+          'unbind-lark': true,
+        },
+      };
+    }
+
+    const defaultAction = '1';
+    console.log('Lark action:');
+    console.log(`  1. ${existing ? 'Bind/rebind bot' : 'Bind bot'}`);
+    if (existing) console.log('  2. Unbind bot');
+    const action = await ask(prompt, 'Choose action', defaultAction);
+    if (existing && (action === '2' || action.toLowerCase() === 'unbind')) {
+      if (!await askYesNo(prompt, `Unbind ${existing.appId} from ${agentKey}?`, false)) throw new Error('Lark bot unbind cancelled');
+      return {
+        agentKey,
+        flags: {
+          ...flags,
+          'lark-config': configPath,
+          'unbind-lark': true,
+        },
+      };
+    }
+
+    const larkFlags = await collectLarkBindFlags(prompt, flags, agentKey, existing?.appId);
+
+    console.log('');
+    console.log('Summary:');
+    console.log(`  agent_key: ${agentKey}`);
+    console.log(`  lark_app_id: ${flag(larkFlags, 'lark-app-id')}`);
+    console.log(`  lark_label: ${flag(larkFlags, 'lark-label') || '-'}`);
+    console.log(`  rebind: ${boolFlag(larkFlags, 'rebind-lark') ? 'yes' : 'no'}`);
+    if (!await askYesNo(prompt, 'Bind this Lark bot?', true)) throw new Error('Lark bot binding cancelled');
+
+    return {
+      agentKey,
+      flags: larkFlags,
     };
   } finally {
     prompt.close();
   }
 }
 
+async function collectAgentDeleteInput(serverClient: LockClient, flags: Record<string, string | boolean>): Promise<string> {
+  const agents = await listAgentRecords(serverClient);
+  const explicitKey = flag(flags, 'key') ?? flag(flags, 'agent');
+  const interactive = boolFlag(flags, 'interactive') || (!explicitKey && process.stdin.isTTY === true);
+  if (!interactive) {
+    if (!explicitKey) throw new Error('agents delete requires --key when not running interactively');
+    if (!boolFlag(flags, 'yes') && !boolFlag(flags, 'force')) throw new Error('agents delete requires --yes to confirm non-interactively');
+    return explicitKey;
+  }
+
+  const prompt = await createPrompt();
+  try {
+    console.log('Delete agent');
+    const agentKey = await askAgentKey(prompt, agents, explicitKey ?? (agents.length === 1 ? '1' : ''));
+    const agent = agents.find((candidate) => candidate.agent_key === agentKey);
+    console.log('');
+    console.log('This will remove the agent record, computer assignment, room memberships, room delivery subscriptions, provider bindings, and active deliveries.');
+    console.log(`  agent_key: ${agentKey}`);
+    console.log(`  display_name: ${agent?.display_name ?? '-'}`);
+    if (!await askYesNo(prompt, `Delete ${agentKey}?`, false)) throw new Error('agent delete cancelled');
+    return agentKey;
+  } finally {
+    prompt.close();
+  }
+}
+
 async function collectLarkUserInput(flags: Record<string, string | boolean>): Promise<{ userId: string; displayName: string | null }> {
   const userIdFlag = flag(flags, 'user-id') ?? flag(flags, 'id');
   const interactive = boolFlag(flags, 'interactive') || (!userIdFlag && process.stdin.isTTY === true);
@@ -359,6 +684,52 @@ async function main(): Promise<void> {
       return;
     }
 
+    if (sub === 'reconnect-command') {
+      let computerId = flag(args.flags, 'computer-id');
+      const interactive = boolFlag(args.flags, 'interactive') || (!computerId && process.stdin.isTTY === true);
+      if (interactive) {
+        const prompt = await createPrompt();
+        try {
+          computerId = await askComputerId(prompt, await serverClient.listComputers());
+        } finally {
+          prompt.close();
+        }
+      }
+      if (!computerId) throw new Error('--computer-id is required');
+      const provisioned = await serverClient.regenerateComputerCommand(computerId, {
+        server_url: flag(args.flags, 'server-url') ?? serverClient.baseUrl,
+        package_name: flag(args.flags, 'package-name') ?? 'bun run daemon',
+      });
+      if (args.flags.json) {
+        printJson(provisioned);
+      } else {
+        console.log('Computer reconnect command generated');
+        printProvisionedComputer(provisioned);
+      }
+      return;
+    }
+
+    if (sub === 'delete') {
+      let computerId = flag(args.flags, 'computer-id');
+      const interactive = boolFlag(args.flags, 'interactive') || (!computerId && process.stdin.isTTY === true);
+      if (interactive) {
+        const prompt = await createPrompt();
+        try {
+          computerId = await askComputerId(prompt, await serverClient.listComputers());
+        } finally {
+          prompt.close();
+        }
+      }
+      if (!computerId) throw new Error('--computer-id is required');
+      const result = await serverClient.deleteComputer(computerId);
+      if (args.flags.json) {
+        printJson(result);
+      } else {
+        console.log(`Computer deleted: ${result.computer.id}`);
+      }
+      return;
+    }
+
     throw new Error(`unknown ${args.command} subcommand: ${sub ?? '(none)'}\n\n${usage()}`);
   }
 
@@ -366,15 +737,12 @@ async function main(): Promise<void> {
     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 ?? [];
+      const agents = await listAgentRecords(serverClient);
       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 ?? '-'}`);
+          console.log(`${agent.agent_key} name="${agent.display_name}" runtime=${agent.runtime ?? '-'} model=${agent.model ?? '-'} desc=${agent.description ?? '-'}`);
         }
       }
       return;
@@ -384,6 +752,7 @@ async function main(): Promise<void> {
       const agentKey = flag(args.flags, 'key');
       const displayName = flag(args.flags, 'name');
       const runtime = flag(args.flags, 'runtime');
+      const model = flag(args.flags, 'model');
       const desc = flag(args.flags, 'desc');
       if (!agentKey) throw new Error('--key is required');
       if (!displayName) throw new Error('--name is required');
@@ -395,6 +764,7 @@ async function main(): Promise<void> {
           agent_key: agentKey,
           display_name: displayName,
           runtime: runtime ?? null,
+          model: await validateRuntimeModel(runtime ?? '', model),
           description: desc ?? null,
         }),
       });
@@ -405,7 +775,7 @@ async function main(): Promise<void> {
     }
 
     if (sub === 'onboard') {
-      const { agentKey, displayName, runtime, desc, computerId } = await collectOnboardInput(serverClient, args.flags);
+      const { agentKey, displayName, runtime, model, desc, computerId, larkFlags } = await collectOnboardInput(serverClient, args.flags);
       if (!agentKey) throw new Error('agent key is required');
       if (!displayName) throw new Error('display name is required');
 
@@ -416,30 +786,89 @@ async function main(): Promise<void> {
           agent_key: agentKey,
           display_name: displayName,
           runtime,
+          model,
           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}`);
+      if (larkFlags) await bindLarkBotToAgent(serverClient, larkFlags, agentKey);
       printJson(payload.data);
       return;
     }
 
     if (sub === 'update') {
-      const agentKey = flag(args.flags, 'key');
-      const runtime = flag(args.flags, 'runtime');
+      const updateInput = boolFlag(args.flags, 'interactive')
+        ? await collectAgentUpdateInput(serverClient, args.flags)
+        : { agentKey: flag(args.flags, 'key') ?? '', flags: args.flags };
+      const agentKey = updateInput.agentKey;
+      const updateFlags = updateInput.flags;
+      const runtime = flag(updateFlags, 'runtime');
+      const hasModel = Object.prototype.hasOwnProperty.call(updateFlags, 'model');
+      const model = flag(updateFlags, 'model');
       if (!agentKey) throw new Error('--key is required');
-      if (!runtime) throw new Error('--runtime is required');
+      const hasLarkBinding = Boolean(flag(updateFlags, 'lark-app-id') || flag(updateFlags, 'app-id') || flag(updateFlags, 'lark-app-secret') || flag(updateFlags, 'app-secret'));
+      const hasLarkUnbind = boolFlag(updateFlags, 'unbind-lark');
+      if (!runtime && !hasModel && !hasLarkBinding && !hasLarkUnbind) throw new Error('--runtime, --model, --lark-app-id/--lark-app-secret, or --unbind-lark is required');
+
+      let agent: Record<string, unknown> | undefined;
+      if (runtime || hasModel) {
+        if (hasModel && typeof model !== 'string') throw new Error('--model requires a value');
+        const existingAgent = hasModel && !runtime
+          ? (await listAgentRecords(serverClient)).find((candidate) => candidate.agent_key === agentKey)
+          : undefined;
+        if (hasModel && !runtime && !existingAgent) throw new Error(`agent ${agentKey} not found`);
+        const runtimeForModel = runtime ?? (typeof existingAgent?.runtime === 'string' ? existingAgent.runtime : '');
+        const response = await fetch(`${serverClient.baseUrl}/api/agents/${encodeURIComponent(agentKey)}`, {
+          method: 'PATCH',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({
+            ...(runtime ? { runtime } : {}),
+            ...(hasModel ? { model: await validateRuntimeModel(runtimeForModel, model) } : {}),
+          }),
+        });
+        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}`);
+        agent = payload.data?.agent;
+      } else {
+        agent = (await listAgentRecords(serverClient)).find((candidate) => candidate.agent_key === agentKey);
+        if (!agent) throw new Error(`agent ${agentKey} not found`);
+      }
 
-      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);
+      if (hasLarkUnbind) await unbindLarkBotFromAgent(serverClient, updateFlags, agentKey);
+      else await bindLarkBotToAgent(serverClient, updateFlags, agentKey);
+      printJson(agent);
+      return;
+    }
+
+    if (sub === 'delete' || sub === 'remove') {
+      const agentKey = await collectAgentDeleteInput(serverClient, args.flags);
+      const params = new URLSearchParams();
+      const configPath = larkConfigPath(args.flags);
+      if (configPath) params.set('lark_config', configPath);
+      const suffix = params.toString() ? `?${params}` : '';
+      const data = await requestJson<{ deletion: Record<string, unknown>; lark: { unbound: boolean; app_id: string | null; error?: string | null } }>(
+        `${serverClient.baseUrl}/api/agents/${encodeURIComponent(agentKey)}${suffix}`,
+        {
+          method: 'DELETE',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ confirm_delete: true, leave_rooms: true, unbind_lark: true }),
+        },
+      );
+      if (data.lark.unbound && !boolFlag(args.flags, 'no-reload')) await reloadLarkIntegration(serverClient.baseUrl);
+      if (args.flags.json) {
+        printJson(data);
+      } else {
+        const deletion = data.deletion;
+        console.log(`Deleted agent ${agentKey}.`);
+        console.log(`  rooms_left: ${deletion.rooms_left}`);
+        console.log(`  subscriptions_removed: ${deletion.subscriptions_removed}`);
+        console.log(`  active_deliveries_canceled: ${deletion.active_deliveries_canceled}`);
+        console.log(`  running_runs_marked_kill: ${deletion.running_runs_marked_kill}`);
+        if (data.lark.unbound) console.log(`  lark_unbound: ${data.lark.app_id}`);
+        if (data.lark.error) console.log(`  lark_unbind_error: ${data.lark.error}`);
+      }
       return;
     }
 
@@ -486,6 +915,11 @@ async function main(): Promise<void> {
     throw new Error(`unknown lark-users subcommand: ${sub ?? '(none)'}\n\n${usage()}`);
   }
 
+  if (args.command === 'messaging') {
+    await runMessagingCommand(serverClient, args, usage);
+    return;
+  }
+
   if (args.command === 'lark') {
     const { runLarkCli } = await import('./lark/cli.js');
     const code = await runLarkCli({