@yeaft/webchat-agent 1.0.356 → 1.0.358

package/cli.js

@@ -64,13 +64,7 @@ if (command === 'doctor') {
 } else if (command === 'llm') {
   await handleLlmCommand(subArgs);
 } else if (command === 'local') {
-  try {
-    const { runLocal } = await import('./local-run.js');
-    await runLocal(subArgs);
-  } catch (error) {
-    console.error(`Local run failed: ${error.message}`);
-    process.exit(1);
-  }
+  await handleLocalCommand(subArgs);
 } else if (command === 'upgrade') {
   await upgrade(subArgs);
 } else if (command === '--version' || command === '-v') {
@@ -84,6 +78,37 @@ if (command === 'doctor') {
   parseAndStart(args);
 }
 
+/** Dispatch the local foreground and managed-service command family. */
+export async function handleLocalCommand(subArgs, options = {}) {
+  const printHelpFn = options.printHelp || printHelp;
+  const warn = options.warn || console.warn;
+  const loadLocalService = options.loadLocalService || (() => import('./local-service.js'));
+  const loadLocalRun = options.loadLocalRun || (() => import('./local-run.js'));
+  try {
+    const localCommand = subArgs[0];
+    if (localCommand === '--help' || localCommand === '-h') {
+      printHelpFn();
+      return;
+    }
+    warnDeprecatedInstanceArg(subArgs, warn);
+    if (SERVICE_COMMANDS.includes(localCommand)) {
+      const { handleLocalServiceCommand } = await loadLocalService();
+      await handleLocalServiceCommand(localCommand, subArgs.slice(1));
+      return;
+    }
+    const { runLocal } = await loadLocalRun();
+    await runLocal(subArgs);
+  } catch (error) {
+    const message = `Local run failed: ${error.message}`;
+    if (options.onError) {
+      options.onError(message, error);
+      return;
+    }
+    console.error(message);
+    process.exit(1);
+  }
+}
+
 function printHelp() {
   console.log(`
   ${pkg.name} v${pkg.version}
@@ -91,6 +116,11 @@ function printHelp() {
   Usage:
     yeaft-agent [options]              Run agent in foreground
     yeaft-agent local [options]        Run local Web UI, server, and agent
+    yeaft-agent local --background      Run local mode in the background
+    yeaft-agent local install [options] Install local mode as a managed service
+    yeaft-agent local uninstall [options] Remove the local managed service
+    yeaft-agent local start|stop|restart|status|logs [options]
+                                      Control the local managed service
     yeaft-agent install [options]      Install as system service
     yeaft-agent uninstall [options]    Remove system service
     yeaft-agent start [options]        Start installed service
@@ -108,6 +138,7 @@ function printHelp() {
     --server <url>      WebSocket server URL (default: ws://localhost:3456)
     --name <name>       Agent name and instance id (default: computer name; invalid chars become -)
     --port <port>       Local server port (local command only; default: 6868)
+    --background, -d    Detach local mode after spawning it (local command only)
     --secret <secret>   Agent secret for authentication
     --work-dir <dir>    Default working directory (default: cwd)
     --yeaft-dir <dir>   Yeaft data directory for this instance
@@ -124,6 +155,8 @@ function printHelp() {
   Examples:
     yeaft-agent local
     yeaft-agent local --name my-worker --port 7000
+    yeaft-agent local --name my-worker --background
+    yeaft-agent local install --name my-worker --port 7000
     yeaft-agent --server wss://your-server.com --name my-worker --secret xxx
     yeaft-agent install --server wss://your-server.com --name my-worker --secret xxx
     yeaft-agent install --server wss://your-server.com --name my-worker-2 --secret xxx

package/local-run.js

@@ -5,18 +5,23 @@ import { createServer } from 'net';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { WebSocket } from 'ws';
-import { resolveDisplayName, validateInstanceId } from './service/config.js';
+import { resolveServiceInstanceId, resolveYeaftDir } from './service/config.js';
 
 const DEFAULT_PORT = 6868;
 const LOCAL_HOST = '127.0.0.1';
 
 export function parseLocalArgs(args, env = process.env) {
-  const options = { name: resolveDisplayName(args, env), port: DEFAULT_PORT };
+  const options = {
+    name: resolveServiceInstanceId(args, env),
+    port: DEFAULT_PORT,
+    background: false,
+    yeaftDir: null,
+  };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     const value = args[i + 1];
-    if (arg === '--name') {
-      if (!value || value.startsWith('-')) throw new Error('--name requires a value');
+    if (arg === '--name' || arg === '--instance' || arg === '--yeaft-dir') {
+      if (!value || value.startsWith('-')) throw new Error(`${arg} requires a value`);
       i++;
     } else if (arg === '--port') {
       if (!value || value.startsWith('-')) throw new Error('--port requires a value');
@@ -24,11 +29,13 @@ export function parseLocalArgs(args, env = process.env) {
       options.port = Number(value);
       if (options.port < 1 || options.port > 65535) throw new Error(`Invalid port: ${value}`);
       i++;
+    } else if (arg === '--background' || arg === '-d') {
+      options.background = true;
     } else {
       throw new Error(`Unknown local option: ${arg}`);
     }
   }
-  validateInstanceId(options.name);
+  options.yeaftDir = resolveYeaftDir(args, env, options.name);
   return options;
 }
 
@@ -127,8 +134,12 @@ function readAgentList(wsUrl) {
 
 export async function runLocal(args, options = {}) {
   const config = parseLocalArgs(args);
+  if (config.background && options.backgroundHandled !== true) {
+    return launchLocalInBackground(args, options);
+  }
   const paths = options.paths || runtimePaths();
   const dataDir = options.dataDir || join(homedir(), '.yeaft', 'server');
+  const yeaftDir = options.yeaftDir || config.yeaftDir;
   const url = `http://${LOCAL_HOST}:${config.port}`;
   const children = new Set();
   const signalHandlers = new Map();
@@ -173,6 +184,7 @@ export async function runLocal(args, options = {}) {
         SERVER_DATA_DIR: dataDir,
         PERF_TRACE_DIR: join(dataDir, 'perf-traces'),
         SKIP_AUTH: 'true',
+        YEAFT_LOCAL_RUN: 'true',
         WEB_DIR: paths.webDir,
       },
     });
@@ -189,6 +201,7 @@ export async function runLocal(args, options = {}) {
         AGENT_NAME: config.name,
         YEAFT_AGENT_INSTANCE: config.name,
         AGENT_SECRET: '',
+        YEAFT_DIR: yeaftDir,
         YEAFT_LOCAL_RUN: 'true',
         YEAFT_SKIP_STARTUP_INSTALLS: 'true',
       },
@@ -204,7 +217,7 @@ export async function runLocal(args, options = {}) {
     server.once('exit', fail('Local server'));
     agent.once('exit', fail('Local agent'));
 
-    await waitForAgent(`ws://${LOCAL_HOST}:${config.port}`, config.name, agent);
+    await (options.waitForAgent || waitForAgent)(`ws://${LOCAL_HOST}:${config.port}`, config.name, agent);
 
     console.log(`Yeaft local is available at ${url}`);
     return { url, server, agent, stop };
@@ -213,3 +226,29 @@ export async function runLocal(args, options = {}) {
     throw error;
   }
 }
+
+function localDaemonArgs(args) {
+  return args.filter(arg => arg !== '--background' && arg !== '-d');
+}
+
+export async function launchLocalInBackground(args, options = {}) {
+  const config = parseLocalArgs(args);
+  const spawnProcess = options.spawn || spawn;
+  const cliPath = options.cliPath || join(dirname(fileURLToPath(import.meta.url)), 'cli.js');
+  const child = spawnProcess(process.execPath, [cliPath, 'local', ...localDaemonArgs(args)], {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: {
+      ...process.env,
+      YEAFT_LOCAL_RUN_BACKGROUND: 'true',
+    },
+  });
+  child.unref();
+  const url = `http://${LOCAL_HOST}:${config.port}`;
+  const result = { url, pid: child.pid, background: true };
+  if (options.quiet !== true) {
+    console.log(`Yeaft local is starting in the background at ${url} (PID ${child.pid}).`);
+  }
+  return result;
+}

package/local-runtime/server/handlers/agent-output.js

@@ -674,7 +674,14 @@ export async function handleAgentOutput(agentId, agent, msg) {
           }
         }
       }
-      if (catalogChanged) await broadcastSessionCatalog(agent.ownerId);
+      // Nested `session_list_updated` events carry the same authoritative
+      // snapshot as the top-level alias below. Re-project the server-owned
+      // catalog after reconciliation so the unified sidebar updates in both
+      // local no-auth and deployed runtimes. Roster changes are handled by
+      // their own metadata branch above.
+      if ((event?.type === 'session_list_updated' || catalogChanged) && agent.ownerId) {
+        await broadcastSessionCatalog(agent.ownerId);
+      }
       break;
     }
 

package/local-runtime/server/ws-agent.js

@@ -4,6 +4,7 @@ import { CONFIG } from './config.js';
 import { verifyAgent } from './auth.js';
 import { encodeKey } from './encryption.js';
 import { agents, pendingAgentConnections } from './context.js';
+import { userDb } from './database.js';
 import {
   parseMessage, broadcastAgentList, clearAgentDirCache
 } from './ws-utils.js';
@@ -114,18 +115,37 @@ export function handleAgentConnection(ws, url) {
 
           const capabilities = Array.isArray(msg.capabilities) ? msg.capabilities : urlCapabilities;
           const agentVersion = msg.version || null;
+          // Local no-auth mode still has one durable browser owner. This makes
+          // the server-side Session catalog persistent without changing generic
+          // development-server behavior, which remains ownerless.
+          const localOwner = skipAgentAuth && process.env.YEAFT_LOCAL_RUN === 'true'
+            ? userDb.getOrCreate('dev-user')
+            : null;
+          const ownerId = localOwner?.id || authResult.userId;
+          const ownerUsername = localOwner?.username || authResult.username;
           // Authenticated Agents use an owner-scoped key. SKIP_AUTH preserves
           // its historical unscoped id while still receiving version metadata.
           resolvedAgentId = skipAgentAuth
             ? clientAgentId
-            : buildAgentMapKey(authResult.userId, pending.instanceId || pending.agentId || pending.agentName);
+            : buildAgentMapKey(ownerId, pending.instanceId || pending.agentId || pending.agentName);
           if (!claimAgentConnection(resolvedAgentId, connectionGeneration)) {
             resolvedAgentId = null;
             pruneAgentConnectionGenerations();
             ws.close(1008, 'Superseded by a newer Agent connection');
             return;
           }
-          completeAgentRegistration(ws, resolvedAgentId, pending.agentName, pending.workDir, authResult.sessionKey, capabilities, authResult.userId, authResult.username, agentVersion, pending.instanceId || pending.agentId || pending.agentName);
+          completeAgentRegistration(
+            ws,
+            resolvedAgentId,
+            pending.agentName,
+            pending.workDir,
+            authResult.sessionKey,
+            capabilities,
+            ownerId,
+            ownerUsername,
+            agentVersion,
+            pending.instanceId || pending.agentId || pending.agentName,
+          );
           pruneAgentConnectionGenerations();
         }
       } catch (e) {

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.356"}
+{"version":"1.0.358"}