@lightcone-ai/daemon 0.23.5 → 0.23.7

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

@@ -94,79 +94,79 @@ function assertNoV5Fields(seg, index) {
   }
 }
 
-// Reading-flow lint — reject the "jump + long hold" anti-pattern that makes
-// recordings feel like a slideshow of screenshots instead of a person
-// scrolling through a page and pausing at key spots to explain. This is what
-// the user repeatedly asked for ("从上往下滑动着介绍，到重点处停一下"). The
-// V6 atom toolkit is fully capable of producing reading-flow output; the
-// problem is that agents default to short-scroll + long-hold without an
-// explicit constraint, so we enforce it here.
+// Transition-mode lint — enforce the "explain block → smooth transition → explain block"
+// pattern the user described:
+//   "先说一句话, 然后再往下滑, 介绍内容 1, 再往下滑, 停住介绍内容 2"
 //
-// Rules:
-//   - Each segment (except the opening hook, segment 0) MUST contain at least
-//     one scroll_to with duration_ms >= 1500ms — the "slow scroll while
-//     narrating" beat.
-//   - Any hold with duration_ms > 2000ms MUST be immediately preceded by a
-//     scroll_to with duration_ms >= 1500ms — long holds are only legal as
-//     "I just slowly scrolled to a key spot, now I'm pausing on it".
-const READING_FLOW_SLOW_SCROLL_MIN_MS = 1500;
-const READING_FLOW_LONG_HOLD_THRESHOLD_MS = 2000;
+// Key insight: scroll_to is a TRANSITION between content blocks, not a
+// narration vehicle. It can be short (~500-800ms) — speed doesn't matter,
+// only smoothness. Long narration happens during hold, not during scroll.
+//
+// Rule (single rule): every non-opening segment MUST start with a scroll_to.
+// This guarantees a visible transition from the previous segment's anchor
+// to the new content block. Without this, an agent can string back-to-back
+// hold-only segments and the viewer just sees jump cuts in audio with no
+// page movement.
+//
+// What's NOT enforced anymore:
+//   - scroll_to duration_ms is not bounded — short transitions (500ms) and
+//     longer ones (2s+) are both fine. Smoothness comes from atomScrollTo's
+//     RAF-based programmatic implementation, not from duration.
+//   - hold duration_ms is not bounded — long holds (3-5s) are the normal
+//     case (this is where the agent narrates the current block).
 
 function validateReadingFlow(operations, segmentIndex) {
-  // Opening hook segment may legitimately be a fully static hero shot
-  // with no scroll (e.g. "校招，实习岗位更新，速投" over a poster).
+  // Opening hook segment is exempt — first segment may legitimately be
+  // a fully static hero shot (e.g. "校招，实习岗位更新，速投" over a poster).
   if (segmentIndex === 0) return;
 
   const ops = Array.isArray(operations) ? operations : [];
   if (ops.length === 0) return;
 
-  const hasSlowScroll = ops.some(
-    op => op?.atom === 'scroll_to' && Number(op.duration_ms) >= READING_FLOW_SLOW_SCROLL_MIN_MS,
-  );
-  if (!hasSlowScroll) {
+  // The first op of a non-opening segment must be a scroll_to (the
+  // transition into this block's content). All-hold segments produce
+  // back-to-back jump cuts with no visible page movement, which the user
+  // has explicitly rejected.
+  const first = ops[0];
+  if (first?.atom !== 'scroll_to') {
     const err = new Error(
-      `reading_flow_violation: segments[${segmentIndex}] has no slow scroll. `
-      + `Reading-flow mode requires at least one scroll_to with duration_ms >= ${READING_FLOW_SLOW_SCROLL_MIN_MS}ms `
-      + 'per non-opening segment — this simulates a finger sliding through the page '
-      + 'while narration plays, instead of jumping cut-style to a position. '
-      + 'Fix: replace any "short scroll_to(duration_ms<1000) + long hold(>2000)" pair '
-      + `with one "slow scroll_to(duration_ms=2000~3500)" + "short hold(duration_ms=800~1500)".`,
+      `transition_required: segments[${segmentIndex}] must start with a scroll_to atom — `
+      + 'this is the smooth transition from the previous block to this one. '
+      + `Got first atom "${first?.atom ?? 'none'}". All-hold segments produce jump cuts. `
+      + 'Fix: prepend a scroll_to(target_y=<new block top>, duration_ms=500~1000) before '
+      + 'the hold. The scroll can be short (~600ms is fine); what matters is that the '
+      + "page visibly slides — atomScrollTo's programmatic mode handles smoothness.",
     );
-    err.code = 'READING_FLOW_VIOLATION';
+    err.code = 'TRANSITION_REQUIRED';
     throw err;
   }
+}
 
-  for (let i = 1; i < ops.length; i += 1) {
-    const op = ops[i];
-    if (op?.atom !== 'hold') continue;
-    const holdMs = Number(op.duration_ms);
-    if (!Number.isFinite(holdMs) || holdMs <= READING_FLOW_LONG_HOLD_THRESHOLD_MS) continue;
-
-    const prev = ops[i - 1];
-    if (prev?.atom !== 'scroll_to') {
-      const err = new Error(
-        `reading_flow_violation: segments[${segmentIndex}].operations[${i}] is a long hold `
-        + `(${holdMs}ms) but its preceding atom is "${prev?.atom ?? 'none'}", not scroll_to. `
-        + 'Long holds (>2000ms) must immediately follow a scroll_to — '
-        + 'the natural reading pattern is "slow scroll to a key spot → pause to explain".',
-      );
-      err.code = 'READING_FLOW_VIOLATION';
-      throw err;
-    }
-    const prevScrollMs = Number(prev.duration_ms);
-    if (!Number.isFinite(prevScrollMs) || prevScrollMs < READING_FLOW_SLOW_SCROLL_MIN_MS) {
-      const err = new Error(
-        `reading_flow_violation: segments[${segmentIndex}].operations[${i}] is a long hold `
-        + `(${holdMs}ms) following a fast scroll_to (${prevScrollMs}ms). This is the "跳页+长停" `
-        + 'anti-pattern — viewers see a hard cut to a new position then a frozen frame. '
-        + `Fix: extend the preceding scroll_to to duration_ms >= ${READING_FLOW_SLOW_SCROLL_MIN_MS}ms `
-        + '(narrate WHILE you scroll), and shorten this hold to duration_ms <= 1500ms '
-        + '(brief pause to stress the key point, then move on).',
-      );
-      err.code = 'READING_FLOW_VIOLATION';
-      throw err;
+// 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.
@@ -241,6 +241,7 @@ function processOperations(operations, audioDurationMs, segmentIndex) {
     sum += n;
   }
   validateReadingFlow(expanded, segmentIndex);
+  validateSingleBlock(expanded, segmentIndex);
   return { operations: expanded, durationSumMs: Math.round(sum) };
 }
 
@@ -312,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.
 //

package/src/_vendor/video/recorder/display-pool.js

@@ -1,126 +0,0 @@
-const DEFAULT_BASE_DISPLAY = 99;
-const DEFAULT_POOL_SIZE = 3;
-
-function normalizePositiveInteger(value, fallback) {
-  const parsed = Number.parseInt(String(value ?? ''), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return parsed;
-}
-
-function createAcquireTimeoutError(timeoutMs) {
-  const error = new Error(`display_pool_acquire_timeout:${timeoutMs}ms`);
-  error.code = 'DISPLAY_POOL_ACQUIRE_TIMEOUT';
-  return error;
-}
-
-function createInvalidPoolError() {
-  const error = new Error('display_pool_invalid_configuration');
-  error.code = 'DISPLAY_POOL_INVALID_CONFIGURATION';
-  return error;
-}
-
-function createSlots({ baseDisplay, poolSize }) {
-  return Array.from({ length: poolSize }, (_unused, index) => {
-    const displayNumber = baseDisplay + index;
-    return {
-      displayNumber,
-      display: `:${displayNumber}`,
-      inUse: false,
-    };
-  });
-}
-
-function createLease(slot, releaseSlot) {
-  let released = false;
-  return Object.freeze({
-    display: slot.display,
-    displayNumber: slot.displayNumber,
-    release() {
-      if (released) return false;
-      released = true;
-      releaseSlot(slot);
-      return true;
-    },
-  });
-}
-
-export function createDisplayPool({
-  baseDisplay = DEFAULT_BASE_DISPLAY,
-  maxConcurrent = DEFAULT_POOL_SIZE,
-} = {}) {
-  const normalizedBaseDisplay = normalizePositiveInteger(baseDisplay, DEFAULT_BASE_DISPLAY);
-  const normalizedPoolSize = normalizePositiveInteger(maxConcurrent, DEFAULT_POOL_SIZE);
-  if (!Number.isFinite(normalizedBaseDisplay) || !Number.isFinite(normalizedPoolSize)) {
-    throw createInvalidPoolError();
-  }
-
-  const slots = createSlots({
-    baseDisplay: normalizedBaseDisplay,
-    poolSize: normalizedPoolSize,
-  });
-  const waiters = [];
-
-  function reserveAvailableSlot() {
-    const slot = slots.find((candidate) => !candidate.inUse);
-    if (!slot) return null;
-    slot.inUse = true;
-    return slot;
-  }
-
-  function dispatchWaiters() {
-    while (waiters.length > 0) {
-      const slot = reserveAvailableSlot();
-      if (!slot) return;
-      const waiter = waiters.shift();
-      if (!waiter) return;
-      if (waiter.timer) clearTimeout(waiter.timer);
-      waiter.resolve(createLease(slot, releaseSlot));
-    }
-  }
-
-  function releaseSlot(slot) {
-    slot.inUse = false;
-    dispatchWaiters();
-  }
-
-  async function acquireDisplay({ timeoutMs = null } = {}) {
-    const slot = reserveAvailableSlot();
-    if (slot) return createLease(slot, releaseSlot);
-
-    return await new Promise((resolve, reject) => {
-      const waiter = {
-        resolve,
-        reject,
-        timer: null,
-      };
-      if (Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0) {
-        const normalizedTimeoutMs = Math.floor(Number(timeoutMs));
-        waiter.timer = setTimeout(() => {
-          const waiterIndex = waiters.indexOf(waiter);
-          if (waiterIndex >= 0) waiters.splice(waiterIndex, 1);
-          reject(createAcquireTimeoutError(normalizedTimeoutMs));
-        }, normalizedTimeoutMs);
-      }
-      waiters.push(waiter);
-    });
-  }
-
-  function snapshot() {
-    return {
-      baseDisplay: normalizedBaseDisplay,
-      maxConcurrent: normalizedPoolSize,
-      waiting: waiters.length,
-      inUse: slots.filter(slot => slot.inUse).map(slot => slot.display),
-      available: slots.filter(slot => !slot.inUse).map(slot => slot.display),
-    };
-  }
-
-  return Object.freeze({
-    baseDisplay: normalizedBaseDisplay,
-    maxConcurrent: normalizedPoolSize,
-    acquireDisplay,
-    snapshot,
-  });
-}
-
-export const defaultDisplayPool = createDisplayPool();