@lightcone-ai/daemon 0.23.6 → 0.23.7

package/src/cli.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { createWriteStream, existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  ensureLightconeDirs,
+  getDaemonStatus,
+  isProcessRunning,
+  readLocalConfig,
+  resolveDaemonLogPath,
+  resolveDaemonPidPath,
+  writeLocalConfig,
+} from './local-config.js';
+import { runDoctor } from './doctor.js';
+
+function parseArgs(raw) {
+  const opts = { _: [] };
+  for (let i = 0; i < raw.length; i += 1) {
+    const arg = raw[i];
+    if (arg.startsWith('--')) {
+      const next = raw[i + 1];
+      if (next && !next.startsWith('--')) {
+        opts[arg] = next;
+        i += 1;
+      } else {
+        opts[arg] = true;
+      }
+    } else {
+      opts._.push(arg);
+    }
+  }
+  return opts;
+}
+
+function printUsage() {
+  console.log(`Usage:
+  lightcone pair --server-url <url> --code <6-digit>
+  lightcone pair --server-url <url> --api-key <sk_machine_...>
+  lightcone daemon start
+  lightcone daemon stop
+  lightcone daemon restart
+  lightcone daemon status
+  lightcone status
+  lightcone doctor [--json]
+  lightcone logs [--lines 100]
+
+Notes:
+  Use --code for normal onboarding, or --api-key for advanced/server installs.`);
+}
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+function redactConfig(config) {
+  const token = String(config?.machineApiKey || '');
+  return {
+    ...config,
+    machineApiKey: token ? `${token.slice(0, 10)}...` : '',
+    localApiToken: config?.localApiToken ? `${String(config.localApiToken).slice(0, 12)}...` : '',
+  };
+}
+
+function requirePairedConfig() {
+  const config = readLocalConfig();
+  if (!config.serverUrl || !config.machineApiKey) {
+    throw new Error('not_paired: run `lightcone pair --server-url <url> --code <6-digit>` first');
+  }
+  return config;
+}
+
+async function exchangePairingCode({ serverUrl, code, name }) {
+  const endpoint = new URL('/api/servers/machine-pairing/exchange', serverUrl);
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      code,
+      name,
+      hostname: os.hostname(),
+      os: `${os.platform()} ${os.arch()} ${os.release()}`,
+    }),
+  });
+  let payload = null;
+  try { payload = await response.json(); } catch {}
+  if (!response.ok) {
+    throw new Error(`pair_code_exchange_failed:${response.status}:${payload?.error ?? response.statusText}`);
+  }
+  const apiKey = String(payload?.apiKey ?? '').trim();
+  if (!apiKey) throw new Error('pair_code_exchange_missing_api_key');
+  return payload;
+}
+
+function daemonEntryPath() {
+  return fileURLToPath(new URL('./index.js', import.meta.url));
+}
+
+function startDaemon({ foreground = false } = {}) {
+  const config = requirePairedConfig();
+  ensureLightconeDirs();
+
+  const current = getDaemonStatus();
+  if (current.running) {
+    console.log(`Daemon already running pid=${current.pid}`);
+    return current;
+  }
+
+  const args = [
+    daemonEntryPath(),
+    '--server-url', config.serverUrl,
+    '--api-key', config.machineApiKey,
+  ];
+
+  if (foreground) {
+    const child = spawn(process.execPath, args, { stdio: 'inherit' });
+    child.on('exit', (code, signal) => process.exit(code ?? (signal ? 1 : 0)));
+    return { running: true, foreground: true };
+  }
+
+  const logPath = resolveDaemonLogPath();
+  const out = createWriteStream(logPath, { flags: 'a' });
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ['ignore', out, out],
+    env: {
+      ...process.env,
+      SERVER_URL: config.serverUrl,
+      MACHINE_API_KEY: config.machineApiKey,
+    },
+  });
+  child.unref();
+  writeFileSync(resolveDaemonPidPath(), `${child.pid}\n`, 'utf8');
+  console.log(`Daemon started pid=${child.pid}`);
+  console.log(`Logs: ${logPath}`);
+  return getDaemonStatus();
+}
+
+function stopDaemon() {
+  const status = getDaemonStatus();
+  if (!status.pid) {
+    console.log('Daemon is not running.');
+    return status;
+  }
+  if (!isProcessRunning(status.pid)) {
+    try { unlinkSync(status.pidPath); } catch {}
+    console.log('Removed stale daemon pid file.');
+    return getDaemonStatus();
+  }
+  process.kill(status.pid, 'SIGTERM');
+  console.log(`Daemon stop requested pid=${status.pid}`);
+  return status;
+}
+
+function tailLogs(lines = 100) {
+  const logPath = resolveDaemonLogPath();
+  if (!existsSync(logPath)) {
+    console.log(`No daemon log found at ${logPath}`);
+    return;
+  }
+  const raw = readFileSync(logPath, 'utf8');
+  const count = Number.parseInt(String(lines), 10);
+  console.log(raw.split(/\r?\n/).slice(-(Number.isFinite(count) && count > 0 ? count : 100)).join('\n'));
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const [command, subcommand] = opts._;
+
+  if (!command || opts['--help'] || opts['-h']) {
+    printUsage();
+    return;
+  }
+
+  if (command === 'pair') {
+    const serverUrl = String(opts['--server-url'] || '').trim();
+    const code = String(opts['--code'] || '').trim();
+    let machineApiKey = String(opts['--api-key'] || '').trim();
+    if (!serverUrl) {
+      throw new Error('pair_requires_server_url');
+    }
+    let exchangePayload = null;
+    if (!machineApiKey && code) {
+      exchangePayload = await exchangePairingCode({
+        serverUrl,
+        code,
+        name: opts['--name'],
+      });
+      machineApiKey = exchangePayload.apiKey;
+    }
+    if (!machineApiKey) {
+      throw new Error('pair_requires_api_key_or_code');
+    }
+    const config = writeLocalConfig({ serverUrl, machineApiKey });
+    console.log(`Paired with ${config.serverUrl}`);
+    if (exchangePayload?.machine?.id) console.log(`Machine: ${exchangePayload.machine.id}`);
+    console.log('Config saved.');
+    return;
+  }
+
+  if (command === 'status' || (command === 'daemon' && subcommand === 'status')) {
+    const status = getDaemonStatus();
+    if (opts['--json']) return printJson({ ...status, config: redactConfig(readLocalConfig()) });
+    console.log(status.running ? `Daemon running pid=${status.pid}` : 'Daemon stopped');
+    console.log(`Home: ${status.home}`);
+    console.log(`Config: ${status.configPath}`);
+    console.log(`Logs: ${status.logPath}`);
+    return;
+  }
+
+  if (command === 'doctor') {
+    const result = runDoctor();
+    if (opts['--json']) return printJson(result);
+    for (const [name, item] of Object.entries(result.required)) {
+      console.log(`${item.ok ? 'ok' : 'missing'} required ${name}: ${item.version || item.error}`);
+    }
+    for (const [name, item] of Object.entries(result.recommended)) {
+      console.log(`${item.ok ? 'ok' : 'missing'} recommended ${name}: ${item.version || item.error}`);
+    }
+    for (const [name, item] of Object.entries(result.runtimes)) {
+      console.log(`${item.ok ? 'ok' : 'missing'} runtime ${name}: ${item.version || item.error}`);
+    }
+    return;
+  }
+
+  if (command === 'logs') {
+    tailLogs(opts['--lines']);
+    return;
+  }
+
+  if (command === 'daemon') {
+    if (subcommand === 'start') {
+      startDaemon({ foreground: !!opts['--foreground'] });
+      return;
+    }
+    if (subcommand === 'stop') {
+      stopDaemon();
+      return;
+    }
+    if (subcommand === 'restart') {
+      stopDaemon();
+      setTimeout(() => startDaemon(), 1000);
+      return;
+    }
+  }
+
+  throw new Error(`unknown_command:${[command, subcommand].filter(Boolean).join(' ')}`);
+}
+
+main().catch((error) => {
+  console.error(`Error: ${error.message}`);
+  process.exitCode = 1;
+});

package/src/doctor.js

@@ -0,0 +1,52 @@
+import { spawnSync } from 'node:child_process';
+
+function commandExists(command, args = ['--version']) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  return {
+    ok: result.status === 0,
+    command,
+    version: String(result.stdout || result.stderr || '').split('\n')[0].trim(),
+    error: result.error?.message || (result.status === 0 ? '' : String(result.stderr || '').trim()),
+  };
+}
+
+function firstAvailable(candidates) {
+  for (const candidate of candidates) {
+    const result = commandExists(candidate.command, candidate.args);
+    if (result.ok) return result;
+  }
+  return {
+    ok: false,
+    command: candidates.map(candidate => candidate.command).join('|'),
+    version: '',
+    error: 'not_found',
+  };
+}
+
+export function runDoctor() {
+  const node = commandExists('node', ['--version']);
+  const npm = commandExists('npm', ['--version']);
+  const chrome = firstAvailable([
+    { command: 'google-chrome', args: ['--version'] },
+    { command: 'google-chrome-stable', args: ['--version'] },
+    { command: 'chromium-browser', args: ['--version'] },
+    { command: 'chromium', args: ['--version'] },
+  ]);
+  const ffmpeg = commandExists('ffmpeg', ['-version']);
+
+  const runtimes = {
+    claude: commandExists('claude', ['--version']),
+    codex: commandExists('codex', ['--version']),
+    kimi: commandExists('kimi', ['--version']),
+  };
+
+  return {
+    ok: node.ok && npm.ok,
+    required: { node, npm },
+    recommended: { chrome, ffmpeg },
+    runtimes,
+  };
+}

package/src/index.js

@@ -5,6 +5,8 @@ import { DaemonConnection } from './connection.js';
 import { AgentManager } from './agent-manager.js';
 import { releaseProfileLocksForProcess } from './profile-lock.js';
 import { resolveLightconeServerUrl } from './runtime-config.js';
+import { readLocalConfig } from './local-config.js';
+import { startLocalApi } from './local-api.js';
 
 const { version } = createRequire(import.meta.url)('../package.json');
 
@@ -30,6 +32,10 @@ function parseArgs(raw) {
 function printUsage() {
   console.log('Usage:');
   console.log('  lightcone-daemon --server-url <url> --api-key <key>');
+  console.log('');
+  console.log('Or configure once and start via:');
+  console.log('  lightcone pair --server-url <url> --code <6-digit>');
+  console.log('  lightcone daemon start');
 }
 
 // ── CLI args ──────────────────────────────────────────────────────────────────
@@ -40,8 +46,26 @@ if (opts['--help'] || opts['-h']) {
   process.exit(0);
 }
 
-const SERVER_URL = String(opts['--server-url'] || resolveLightconeServerUrl()).trim();
-const MACHINE_API_KEY = String(opts['--api-key'] || process.env.MACHINE_API_KEY || '').trim();
+let localConfig = {};
+try {
+  localConfig = readLocalConfig();
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  process.exit(1);
+}
+
+const SERVER_URL = String(
+  opts['--server-url']
+  || process.env.SERVER_URL
+  || localConfig.serverUrl
+  || resolveLightconeServerUrl()
+).trim();
+const MACHINE_API_KEY = String(
+  opts['--api-key']
+  || process.env.MACHINE_API_KEY
+  || localConfig.machineApiKey
+  || ''
+).trim();
 
 if (!MACHINE_API_KEY) {
   console.error('Error: API key is required.');
@@ -61,6 +85,7 @@ const connection = new DaemonConnection({
   getAgentInventory: () => agentManager.getAgentInventory(),
 });
 
+let localApi = null;
 connection.connect();
 
 let shuttingDown = false;
@@ -68,12 +93,21 @@ async function shutdown(signal) {
   if (shuttingDown) return;
   shuttingDown = true;
   console.log(`[Daemon] Shutting down (${signal})`);
+  try { localApi?.close(); } catch {}
   connection.stop();
   try { await agentManager.stopAll(); } catch (err) { console.error('[Daemon] Shutdown error:', err.message); }
   releaseProfileLocksForProcess();
   process.exit(0);
 }
 
+localApi = startLocalApi({
+  serverUrl: SERVER_URL,
+  version,
+  connection,
+  agentManager,
+  onStop: shutdown,
+});
+
 process.on('SIGINT', () => { shutdown('SIGINT'); });
 process.on('SIGTERM', () => { shutdown('SIGTERM'); });
 process.on('SIGHUP', () => { shutdown('SIGHUP'); });

package/src/local-api.js

@@ -0,0 +1,106 @@
+import http from 'node:http';
+import { readFileSync } from 'node:fs';
+
+import { getDaemonStatus, readLocalConfig, resolveDaemonLogPath } from './local-config.js';
+import { runDoctor } from './doctor.js';
+
+function sendJson(res, statusCode, payload) {
+  const body = `${JSON.stringify(payload, null, 2)}\n`;
+  res.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body),
+  });
+  res.end(body);
+}
+
+function bearerToken(req) {
+  const auth = String(req.headers.authorization || '').trim();
+  if (auth.toLowerCase().startsWith('bearer ')) return auth.slice(7).trim();
+  return String(req.headers['x-lightcone-local-token'] || '').trim();
+}
+
+function isAuthorized(req, config) {
+  const expected = String(config.localApiToken || '').trim();
+  return !!expected && bearerToken(req) === expected;
+}
+
+function safeConnectionState(connection) {
+  const ws = connection?.ws;
+  return {
+    stopped: !!connection?.stopped,
+    readyState: ws?.readyState ?? null,
+    connected: ws?.readyState === 1,
+  };
+}
+
+export function startLocalApi({
+  serverUrl,
+  version,
+  connection,
+  agentManager,
+  onStop,
+  env = process.env,
+} = {}) {
+  const config = readLocalConfig(env);
+  const port = Number.parseInt(String(env.LIGHTCONE_LOCAL_API_PORT || config.localApiPort || 19876), 10) || 19876;
+
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+
+    if (req.method === 'GET' && url.pathname === '/health') {
+      return sendJson(res, 200, { ok: true, service: 'lightcone-daemon', version });
+    }
+
+    if (!isAuthorized(req, config)) {
+      return sendJson(res, 401, { error: 'unauthorized' });
+    }
+
+    if (req.method === 'GET' && url.pathname === '/status') {
+      return sendJson(res, 200, {
+        ok: true,
+        version,
+        serverUrl,
+        daemon: getDaemonStatus(env),
+        connection: safeConnectionState(connection),
+        inventory: typeof agentManager?.getAgentInventory === 'function'
+          ? agentManager.getAgentInventory()
+          : [],
+      });
+    }
+
+    if (req.method === 'GET' && url.pathname === '/doctor') {
+      return sendJson(res, 200, runDoctor());
+    }
+
+    if (req.method === 'GET' && url.pathname === '/logs') {
+      const lines = Number.parseInt(url.searchParams.get('lines') || '200', 10);
+      let text = '';
+      try {
+        text = readFileSync(resolveDaemonLogPath(env), 'utf8')
+          .split(/\r?\n/)
+          .slice(-(Number.isFinite(lines) && lines > 0 ? lines : 200))
+          .join('\n');
+      } catch {}
+      res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+      res.end(text);
+      return;
+    }
+
+    if (req.method === 'POST' && url.pathname === '/stop') {
+      sendJson(res, 202, { ok: true });
+      setTimeout(() => onStop?.('LOCAL_API'), 20);
+      return;
+    }
+
+    return sendJson(res, 404, { error: 'not_found' });
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    console.log(`[LocalAPI] Listening on http://127.0.0.1:${port}`);
+  });
+  server.on('error', (error) => {
+    console.error(`[LocalAPI] Failed: ${error.message}`);
+  });
+
+  return server;
+}

package/src/local-config.js

@@ -0,0 +1,116 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const DEFAULT_CONFIG = Object.freeze({
+  serverUrl: '',
+  machineApiKey: '',
+  localApiPort: 19876,
+  localApiToken: '',
+});
+
+function normalizeText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function resolveLightconeHome(env = process.env) {
+  return path.resolve(normalizeText(env.LIGHTCONE_HOME) || path.join(os.homedir(), '.lightcone'));
+}
+
+export function resolveConfigPath(env = process.env) {
+  return path.join(resolveLightconeHome(env), 'config.json');
+}
+
+export function resolveLogsDir(env = process.env) {
+  return path.join(resolveLightconeHome(env), 'logs');
+}
+
+export function resolveDaemonLogPath(env = process.env) {
+  return path.join(resolveLogsDir(env), 'daemon.log');
+}
+
+export function resolveDaemonPidPath(env = process.env) {
+  return path.join(resolveLightconeHome(env), 'daemon.pid');
+}
+
+export function ensureLightconeDirs(env = process.env) {
+  const home = resolveLightconeHome(env);
+  mkdirSync(home, { recursive: true });
+  mkdirSync(resolveLogsDir(env), { recursive: true });
+  mkdirSync(path.join(home, 'bin'), { recursive: true });
+  mkdirSync(path.join(home, 'chrome-profiles'), { recursive: true });
+  return home;
+}
+
+export function readLocalConfig(env = process.env) {
+  const configPath = resolveConfigPath(env);
+  if (!existsSync(configPath)) return { ...DEFAULT_CONFIG };
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8'));
+    return {
+      ...DEFAULT_CONFIG,
+      ...(parsed && typeof parsed === 'object' ? parsed : {}),
+      serverUrl: normalizeText(parsed?.serverUrl ?? parsed?.server_url),
+      machineApiKey: normalizeText(parsed?.machineApiKey ?? parsed?.machine_api_key),
+      localApiPort: Number.parseInt(String(parsed?.localApiPort ?? parsed?.local_api_port ?? DEFAULT_CONFIG.localApiPort), 10) || DEFAULT_CONFIG.localApiPort,
+      localApiToken: normalizeText(parsed?.localApiToken ?? parsed?.local_api_token),
+    };
+  } catch (error) {
+    const wrapped = new Error(`local_config_invalid:${error.message}`);
+    wrapped.code = 'LOCAL_CONFIG_INVALID';
+    wrapped.configPath = configPath;
+    throw wrapped;
+  }
+}
+
+export function writeLocalConfig(config, env = process.env) {
+  ensureLightconeDirs(env);
+  const configPath = resolveConfigPath(env);
+  const current = readLocalConfig(env);
+  const next = {
+    ...current,
+    ...config,
+    localApiToken: normalizeText(config?.localApiToken ?? current.localApiToken) || `lc_local_${randomBytes(24).toString('hex')}`,
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  try { chmodSync(configPath, 0o600); } catch {}
+  return next;
+}
+
+export function readDaemonPid(env = process.env) {
+  const pidPath = resolveDaemonPidPath(env);
+  if (!existsSync(pidPath)) return null;
+  const raw = normalizeText(readFileSync(pidPath, 'utf8'));
+  const pid = Number.parseInt(raw, 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+export function isProcessRunning(pid) {
+  if (!Number.isFinite(Number(pid)) || Number(pid) <= 0) return false;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getDaemonStatus(env = process.env) {
+  const pid = readDaemonPid(env);
+  const logPath = resolveDaemonLogPath(env);
+  let logSizeBytes = 0;
+  try {
+    if (existsSync(logPath)) logSizeBytes = statSync(logPath).size;
+  } catch {}
+  return {
+    running: pid ? isProcessRunning(pid) : false,
+    pid,
+    pidPath: resolveDaemonPidPath(env),
+    logPath,
+    logSizeBytes,
+    configPath: resolveConfigPath(env),
+    home: resolveLightconeHome(env),
+  };
+}

package/src/tools/plan-video-segments.js

@@ -142,6 +142,33 @@ function validateReadingFlow(operations, segmentIndex) {
   }
 }
 
+// 1 section ↔ 1 block — the V6 audio/visual sync contract. A section's
+// scroll_to operations may reference at most one distinct block id: the
+// section narrates that block while it sits framed. A section that scrolls
+// across two blocks has no single "what is narrated" → "what is framed"
+// mapping, which is the whole basis of staying in sync. Sections with no
+// block reference (e.g. the opening lead-in drift on raw `y`) are unaffected.
+// A tall block panned over a top-aligned + bottom-aligned scroll_to still
+// references one block id, so it passes.
+function validateSingleBlock(operations, segmentIndex) {
+  const ids = new Set();
+  for (const op of operations) {
+    if (op?.atom === 'scroll_to' && typeof op.block === 'string' && op.block.trim()) {
+      ids.add(op.block.trim());
+    }
+  }
+  if (ids.size > 1) {
+    const err = new Error(
+      `section_spans_multiple_blocks: segments[${segmentIndex}] references ${ids.size} different `
+      + `blocks (${[...ids].join(', ')}) in one section. V6 contract: one narration segment ↔ one `
+      + 'block — the segment narrates that block while it stays framed. Split this into one segment '
+      + 'per block.',
+    );
+    err.code = 'SECTION_SPANS_MULTIPLE_BLOCKS';
+    throw err;
+  }
+}
+
 // Process operations[]: expand "fill" on the last hold, validate atom shape.
 function processOperations(operations, audioDurationMs, segmentIndex) {
   if (!Array.isArray(operations) || operations.length === 0) {
@@ -214,6 +241,7 @@ function processOperations(operations, audioDurationMs, segmentIndex) {
     sum += n;
   }
   validateReadingFlow(expanded, segmentIndex);
+  validateSingleBlock(expanded, segmentIndex);
   return { operations: expanded, durationSumMs: Math.round(sum) };
 }
 
@@ -285,8 +313,13 @@ export async function runPlanVideoSegmentsTool({ segments } = {}) {
       const perCard = Math.max(2, Math.ceil((totalDuration / numCards) * 2) / 2);
       presentation = { per_card_duration: perCard };
     } else {
-      const duration = planDurationSec(audioDurationMs, kind === 'scroll' ? 1.0 : 0.5);
-      presentation = { duration, ...(kind === 'scroll' ? { style: 'scroll' } : {}) };
+      // Scroll-style images (a tall image ffmpeg pans over) need a longer
+      // buffer — the eye follows motion slower than it reads a static frame.
+      // The scroll style lives on presentation.style, NOT visual_kind
+      // (visual_kind is only image / video / gif / carousel).
+      const isScroll = String(seg.presentation?.style ?? '') === 'scroll';
+      const duration = planDurationSec(audioDurationMs, isScroll ? 1.0 : 0.5);
+      presentation = { duration, ...(isScroll ? { style: 'scroll' } : {}) };
     }
 
     planned.push({

package/src/tools/record-url-narration.js

@@ -1,6 +1,6 @@
 // V6 record_url_narration daemon tool wrapper.
 //
-// Drives Chromium on Xvfb + Playwright recordVideo to capture a silent mp4
+// Drives headless Chromium + Playwright recordVideo to capture a silent mp4
 // per section, then ffmpeg-transcodes + slices. The resulting silent mp4s
 // feed compose_video_v2 as video-kind segments alongside narration audio.
 //