@yeaft/webchat-agent 1.0.414 → 1.0.415

package/workbench/request-routing.js

@@ -0,0 +1,16 @@
+export function workbenchRequestRouting(source) {
+  return {
+    ...(source?._workbenchRequestId ? { _workbenchRequestId: source._workbenchRequestId } : {}),
+    ...(source?.workbenchRouteKey ? { workbenchRouteKey: source.workbenchRouteKey } : {}),
+    ...(source?.workbenchWorkspaceGeneration
+      ? { workbenchWorkspaceGeneration: source.workbenchWorkspaceGeneration }
+      : {}),
+  };
+}
+
+export function sendWorkbenchResult(ctx, request, result) {
+  ctx.sendToServer({
+    ...result,
+    ...workbenchRequestRouting(request),
+  });
+}

package/yeaft/cli.js

@@ -25,6 +25,7 @@
 
 import { createInterface } from 'readline';
 import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { join } from 'path';
@@ -35,13 +36,16 @@ import { listModels, resolveModel, parseModelRef, resolveContextWindow, resolveM
 import { buildSystemPrompt } from './prompts.js';
 import { searchMessages } from './conversation/search.js';
 import { ConversationStore } from './conversation/persist.js';
-import { snapshotSessions } from './sessions/session-crud.js';
+import { sessionsRoot, snapshotSessions } from './sessions/session-crud.js';
 import { loadSessionConfig, resolveSessionConfig } from './sessions/session-config.js';
+import { createSession } from './sessions/session-store.js';
+import { addOrUpdateManifestSession, withSessionManifestLock } from './sessions/session-manifest.js';
 import { validateSessionId } from './sessions/ids.js';
 import {
   createJsonlWriter,
   JsonlInput,
   normalizeStreamRoutingIntent,
+  normalizeStreamSessionBootstrap,
   runStreamTurn,
   runStreamSessionTurn,
 } from './stdio-protocol.js';
@@ -900,6 +904,7 @@ async function runStreamJson(config, args) {
   let taskEventIntakeOpen = true;
   let hadError = false;
   let singleEngineTail = Promise.resolve();
+  let streamSessionBootstrapOpen = false;
 
   const loadStreamHistory = () => conversationStore.loadRecentBySession(sessionId, 20).map(message => ({
     role: message.role,
@@ -1033,6 +1038,16 @@ async function runStreamJson(config, args) {
 
   configureStreamEngine(engine, null);
   sessionRunner = createCliSessionRunner({ loaded, sessionId, workDir, configureEngine: configureStreamEngine });
+  if (sessionRunner) {
+    snapshotSessions(loaded.yeaftDir);
+    const meta = sessionRunner.meta;
+    if (meta) addOrUpdateManifestSession(
+      loaded.yeaftDir,
+      meta,
+      join(sessionsRoot(loaded.yeaftDir), sessionId),
+    );
+  }
+  streamSessionBootstrapOpen = !sessionRunner;
 
   write({
     type: 'system',
@@ -1091,6 +1106,47 @@ async function runStreamJson(config, args) {
   };
 
   const runPrompt = async (prompt, message = null) => {
+    if (streamSessionBootstrapOpen) {
+      streamSessionBootstrapOpen = false;
+      const bootstrap = normalizeStreamSessionBootstrap(message);
+      if (bootstrap) {
+        let workspaceKey = '';
+        try { workspaceKey = realpathSync(resolve(workDir)); } catch { /* leave empty */ }
+        withSessionManifestLock(loaded.yeaftDir, () => {
+          sessionRunner = createCliSessionRunner({
+            loaded,
+            sessionId,
+            workDir,
+            configureEngine: configureStreamEngine,
+          });
+          if (sessionRunner) return;
+          const handle = createSession(sessionsRoot(loaded.yeaftDir), {
+            id: sessionId,
+            name: sessionId,
+            roster: bootstrap.roster,
+            defaultVpId: bootstrap.defaultVpId,
+            workDir,
+            workspaceKey,
+          });
+          handle.close();
+        });
+        if (!sessionRunner) {
+          sessionRunner = createCliSessionRunner({
+            loaded,
+            sessionId,
+            workDir,
+            configureEngine: configureStreamEngine,
+          });
+        }
+        if (!sessionRunner) throw new Error(`Failed to initialize formal stream-json Session ${sessionId}`);
+        const meta = sessionRunner.meta;
+        if (meta) addOrUpdateManifestSession(
+          loaded.yeaftDir,
+          meta,
+          join(sessionsRoot(loaded.yeaftDir), sessionId),
+        );
+      }
+    }
     const routingIntent = normalizeStreamRoutingIntent(message);
     if (routingIntent && !sessionRunner) {
       throw new Error('stream-json VP selectors require an existing formal Session with a persisted roster');

package/yeaft/sessions/session-manifest.js

@@ -15,18 +15,25 @@
 import {
   cpSync,
   existsSync,
+  linkSync,
   mkdirSync,
   readFileSync,
   readdirSync,
   rmSync,
   statSync,
+  unlinkSync,
   writeFileSync,
 } from 'fs';
+import { randomUUID } from 'node:crypto';
 import { join } from 'path';
 import { loadSessionMeta } from './session-store.js';
+import { writeAtomic } from '../storage/atomic.js';
 
 export const SESSIONS_MANIFEST_FILE = 'sessions-manifest.json';
 const MANIFEST_VERSION = 1;
+const MANIFEST_LOCK_FILE = 'sessions-manifest.lock';
+const MANIFEST_LOCK_WAIT_MS = 5_000;
+const lockWaitArray = new Int32Array(new SharedArrayBuffer(4));
 
 export function sessionManifestPath(yeaftDir) {
   return join(yeaftDir, SESSIONS_MANIFEST_FILE);
@@ -62,6 +69,10 @@ export function loadSessionsManifest(yeaftDir) {
 }
 
 export function writeSessionsManifest(yeaftDir, sessions) {
+  return withManifestLock(yeaftDir, () => writeSessionsManifestUnlocked(yeaftDir, sessions));
+}
+
+function writeSessionsManifestUnlocked(yeaftDir, sessions) {
   if (!yeaftDir) throw new Error('yeaftDir required');
   mkdirSync(yeaftDir, { recursive: true });
   const manifest = {
@@ -69,7 +80,7 @@ export function writeSessionsManifest(yeaftDir, sessions) {
     generatedAt: new Date().toISOString(),
     sessions: dedupeSessions(sessions).sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || ''))),
   };
-  writeFileSync(sessionManifestPath(yeaftDir), `${JSON.stringify(manifest, null, 2)}\n`);
+  writeAtomic(sessionManifestPath(yeaftDir), `${JSON.stringify(manifest, null, 2)}\n`);
   return manifest;
 }
 
@@ -171,21 +182,114 @@ export function ensureSessionsManifest(yeaftDir, options) {
     }
   }
 
-  const manifest = writeSessionsManifest(yeaftDir, buildManifestFromLocalSessions(yeaftDir, root));
-  return { created: true, migrated, skipped, migratedIds, skippedIds, manifest };
+  return withManifestLock(yeaftDir, () => {
+    const current = loadSessionsManifest(yeaftDir);
+    const manifest = writeSessionsManifestUnlocked(yeaftDir, [
+      ...(current?.sessions || []),
+      ...buildManifestFromLocalSessions(yeaftDir, root),
+    ]);
+    return {
+      created: !current,
+      migrated,
+      skipped,
+      migratedIds,
+      skippedIds,
+      manifest,
+    };
+  });
 }
 
 export function addOrUpdateManifestSession(yeaftDir, meta, dir) {
-  const current = loadSessionsManifest(yeaftDir) || { sessions: [] };
-  const rows = current.sessions.filter(row => row.id !== meta.id);
-  rows.push(manifestRowFromMeta(meta, dir));
-  return writeSessionsManifest(yeaftDir, rows);
+  return withManifestLock(yeaftDir, () => {
+    const current = loadSessionsManifest(yeaftDir);
+    const recovered = current?.sessions
+      || buildManifestFromLocalSessions(yeaftDir, join(yeaftDir, 'sessions'));
+    const rows = recovered.filter(row => row.id !== meta.id);
+    rows.push(manifestRowFromMeta(meta, dir));
+    return writeSessionsManifestUnlocked(yeaftDir, rows);
+  });
 }
 
 export function removeManifestSession(yeaftDir, sessionId) {
-  const current = loadSessionsManifest(yeaftDir);
-  if (!current) return null;
-  return writeSessionsManifest(yeaftDir, current.sessions.filter(row => row.id !== sessionId));
+  return withManifestLock(yeaftDir, () => {
+    const current = loadSessionsManifest(yeaftDir);
+    if (!current) return null;
+    return writeSessionsManifestUnlocked(yeaftDir, current.sessions.filter(row => row.id !== sessionId));
+  });
+}
+
+export function withSessionManifestLock(yeaftDir, operation) {
+  if (!yeaftDir) throw new Error('yeaftDir required');
+  mkdirSync(yeaftDir, { recursive: true });
+  const lockFile = join(yeaftDir, MANIFEST_LOCK_FILE);
+  const deadline = Date.now() + MANIFEST_LOCK_WAIT_MS;
+  const token = randomUUID();
+  const ownerFile = `${lockFile}.owner.${process.pid}.${token}`;
+  const owner = { pid: process.pid, token, ownerFile };
+  writeFileSync(ownerFile, `${JSON.stringify(owner)}\n`, { flag: 'wx' });
+  for (;;) {
+    try {
+      linkSync(ownerFile, lockFile);
+      break;
+    } catch (error) {
+      if (error?.code !== 'EEXIST') {
+        try { unlinkSync(ownerFile); } catch {}
+        throw error;
+      }
+      reapDeadManifestLock(lockFile);
+      if (Date.now() >= deadline) {
+        try { unlinkSync(ownerFile); } catch {}
+        throw new Error('Timed out waiting for Session manifest lock');
+      }
+      Atomics.wait(lockWaitArray, 0, 0, 25);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    try {
+      const current = JSON.parse(readFileSync(lockFile, 'utf8'));
+      if (current.token === owner.token) unlinkSync(lockFile);
+    } catch {
+      // A missing lock means another process already recovered this owner.
+    }
+    try { unlinkSync(ownerFile); } catch {}
+  }
+}
+
+function withManifestLock(yeaftDir, operation) {
+  return withSessionManifestLock(yeaftDir, operation);
+}
+
+function reapDeadManifestLock(lockFile) {
+  let observed;
+  try {
+    observed = JSON.parse(readFileSync(lockFile, 'utf8'));
+  } catch {
+    return;
+  }
+  if (!Number.isInteger(observed.pid) || typeof observed.token !== 'string') return;
+  try {
+    process.kill(observed.pid, 0);
+    return;
+  } catch (error) {
+    if (error?.code === 'EPERM') return;
+  }
+  const claim = `${lockFile}.reap.${process.pid}.${randomUUID()}`;
+  try {
+    linkSync(lockFile, claim);
+    const claimed = JSON.parse(readFileSync(claim, 'utf8'));
+    if (claimed.token !== observed.token) return;
+    unlinkSync(lockFile);
+    const expectedOwnerFile = `${lockFile}.owner.${observed.pid}.${observed.token}`;
+    if (observed.ownerFile === expectedOwnerFile) {
+      try { unlinkSync(expectedOwnerFile); } catch {}
+    }
+  } catch {
+    // Another process either recovered or replaced the observed lock.
+  } finally {
+    try { unlinkSync(claim); } catch {}
+  }
 }
 
 function manifestRowFromMeta(meta, dir) {

package/yeaft/stdio-protocol.js

@@ -1,5 +1,6 @@
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
+import { isReservedVpId, validateVpId } from './sessions/ids.js';
 
 const TERMINAL_STOP_REASONS = new Set([
   'end_turn', 'max_tokens', 'stop_sequence', 'aborted', 'error', 'tool_handoff', 'plan_recorded',
@@ -78,6 +79,62 @@ export function normalizeStreamRoutingIntent(message) {
   });
 }
 
+/**
+ * Read the opt-in formal Session seed supplied by an integration's first
+ * stream-json prompt. Existing Sessions keep their persisted roster; this only
+ * establishes a canonical roster for a previously unknown session id.
+ */
+export function normalizeStreamSessionBootstrap(message) {
+  if (!message || typeof message !== 'object') return null;
+  const hasRoster = Object.hasOwn(message, 'roster');
+  const hasVps = Object.hasOwn(message, 'vps');
+  const hasDefault = Object.hasOwn(message, 'defaultVpId');
+  if (!hasRoster && !hasVps && !hasDefault) return null;
+  if (!hasRoster && !hasVps) {
+    throw new Error('stream-json defaultVpId requires roster or vps');
+  }
+
+  const readRoster = (key) => {
+    const value = message[key];
+    if (!Array.isArray(value)) throw new Error(`stream-json ${key} must be an array`);
+    return value.slice();
+  };
+  const roster = hasRoster ? readRoster('roster') : readRoster('vps');
+  if (hasRoster && hasVps) {
+    const vps = readRoster('vps');
+    if (vps.length !== roster.length || vps.some((vpId, index) => vpId !== roster[index])) {
+      throw new Error('stream-json roster and vps must contain the same VP ids in the same order');
+    }
+  }
+
+  const seen = new Set();
+  for (const vpId of roster) {
+    const verdict = validateVpId(vpId);
+    if (!verdict.ok || isReservedVpId(vpId)) {
+      throw new Error(`stream-json roster contains invalid VP id ${JSON.stringify(vpId)} (${verdict.reason || 'reserved'})`);
+    }
+    if (seen.has(vpId)) throw new Error(`stream-json roster contains duplicate VP id ${vpId}`);
+    seen.add(vpId);
+  }
+
+  let defaultVpId = roster[0] || null;
+  if (hasDefault && message.defaultVpId != null) {
+    defaultVpId = message.defaultVpId;
+    const verdict = validateVpId(defaultVpId);
+    if (!verdict.ok || isReservedVpId(defaultVpId)) {
+      throw new Error(`stream-json defaultVpId is invalid (${verdict.reason || 'reserved'})`);
+    }
+    if (!seen.has(defaultVpId)) {
+      throw new Error(`stream-json defaultVpId ${defaultVpId} is not in roster`);
+    }
+  }
+
+  return Object.freeze({
+    roster: Object.freeze(roster),
+    defaultVpId,
+  });
+}
+
 export function createJsonlWriter(output = process.stdout) {
   return event => { output.write(`${JSON.stringify(event)}\n`); };
 }