@yeaft/webchat-agent 1.0.357 → 1.0.359

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/index.js

@@ -10,7 +10,14 @@ import { exec } from 'child_process';
 import { promisify } from 'util';
 import { fileURLToPath } from 'url';
 import ctx from './context.js';
-import { getDefaultAgentName, getDefaultYeaftDir, resolveRuntimeIdentity, getConfigPath, loadServiceConfig } from './service.js';
+import {
+  getDefaultAgentName,
+  getDefaultYeaftDir,
+  resolveRuntimeIdentity,
+  getConfigPath,
+  loadServiceConfig,
+  shouldLoadLegacyLocalConfig,
+} from './service.js';
 import { loadNodePty } from './terminal.js';
 import { connect } from './connection.js';
 import { loadMcpServers } from './mcp.js';
@@ -37,7 +44,8 @@ const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
 ctx.agentVersion = pkg.version;
 ctx.pkgName = pkg.name;
 
-// 配置文件路径（向后兼容：先查当前目录 .claude-agent.json）
+// Legacy direct launches may still read cwd/.claude-agent.json. Explicit
+// service instances must stay scoped to their standard per-instance config.
 const LOCAL_CONFIG_FILE = join(process.cwd(), '.claude-agent.json');
 const IS_LOCAL_RUN = process.env.YEAFT_LOCAL_RUN === 'true';
 const DEFAULT_AGENT_NAME = getDefaultAgentName();
@@ -56,8 +64,10 @@ function loadConfig() {
   // must not inherit a remote agent's persisted configuration.
   if (IS_LOCAL_RUN) return defaults;
 
-  // Priority 1: Local .claude-agent.json (backward compat)
-  if (existsSync(LOCAL_CONFIG_FILE)) {
+  // Priority 1: Local .claude-agent.json (backward compat for unscoped launches only).
+  // A named service can share its cwd with an unrelated legacy launch, so the
+  // process-level instance identity must fence this unscoped file out.
+  if (shouldLoadLegacyLocalConfig(process.env) && existsSync(LOCAL_CONFIG_FILE)) {
     try {
       const saved = JSON.parse(readFileSync(LOCAL_CONFIG_FILE, 'utf-8'));
       const { agentId, ...rest } = saved;
@@ -77,7 +87,7 @@ function loadConfig() {
 }
 
 function saveConfig(config) {
-  if (IS_LOCAL_RUN) return;
+  if (IS_LOCAL_RUN || !shouldLoadLegacyLocalConfig(process.env)) return;
   writeFileSync(LOCAL_CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 

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.357"}
+{"version":"1.0.359"}

package/local-service.js

@@ -0,0 +1,219 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { homedir, platform } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import {
+  getConfigDir,
+  getDefaultYeaftDir,
+  getNodePath,
+  resolveServiceInstanceId,
+  resolveYeaftDir,
+  validateInstanceId,
+} from './service/config.js';
+
+const LOCAL_SERVICE_PREFIX = 'yeaft-local';
+const DEFAULT_PORT = 6868;
+const SYSTEMD_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+
+/** Parse local service identity, runtime port, and resolved persistent data root. */
+export function parseLocalServiceArgs(args, env = process.env, options = {}) {
+  const parsed = {
+    name: resolveServiceInstanceId(args, env),
+    port: DEFAULT_PORT,
+    yeaftDir: null,
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    const value = args[index + 1];
+    if (arg === '--name' || arg === '--instance' || arg === '--yeaft-dir') {
+      if (!value || value.startsWith('-')) throw new Error(`${arg} requires a value`);
+      index += 1;
+    } else if (arg === '--port') {
+      if (!value || value.startsWith('-')) throw new Error('--port requires a value');
+      if (!/^\d+$/.test(value)) throw new Error(`Invalid port: ${value}`);
+      parsed.port = Number(value);
+      if (parsed.port < 1 || parsed.port > 65535) throw new Error(`Invalid port: ${value}`);
+      index += 1;
+    } else {
+      throw new Error(`Unknown local service option: ${arg}`);
+    }
+  }
+  parsed.name = validateInstanceId(parsed.name);
+  const existing = options.existing || null;
+  const hasExplicitYeaftDir = args.includes('--yeaft-dir') || Boolean(env.YEAFT_DIR);
+  parsed.yeaftDir = hasExplicitYeaftDir
+    ? resolveYeaftDir(args, env, parsed.name)
+    : existing?.yeaftDir || getDefaultYeaftDir(parsed.name);
+  assertSystemdValue(parsed.yeaftDir, 'Yeaft data directory');
+  return parsed;
+}
+
+function assertSystemdValue(value, label) {
+  if (SYSTEMD_CONTROL_CHARACTERS.test(String(value))) {
+    throw new Error(`${label} cannot contain control characters when installing a systemd service`);
+  }
+}
+
+export function getLocalServiceName(name) {
+  return `${LOCAL_SERVICE_PREFIX}@${validateInstanceId(name)}`;
+}
+
+export function getLocalServiceConfigPath(name) {
+  return join(getConfigDir(name), 'local.json');
+}
+
+export function getLocalSystemdServicePath(name) {
+  return join(homedir(), '.config', 'systemd', 'user', `${getLocalServiceName(name)}.service`);
+}
+
+export function getLocalSystemdUnitPath(name) {
+  return getLocalSystemdServicePath(name);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function systemdEscape(value) {
+  assertSystemdValue(value, 'systemd unit value');
+  return String(value)
+    .replaceAll('%', '%%')
+    .replaceAll('\\', '\\\\')
+    .replaceAll('"', '\\"');
+}
+
+/** Read the persisted local service settings, including its resolved data root. */
+export function readLocalServiceConfig(name) {
+  const path = getLocalServiceConfigPath(name);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return null;
+    const configName = validateInstanceId(parsed.name || name);
+    return {
+      name: configName,
+      port: Number(parsed.port) || DEFAULT_PORT,
+      yeaftDir: typeof parsed.yeaftDir === 'string' && parsed.yeaftDir
+        ? parsed.yeaftDir
+        : getDefaultYeaftDir(configName),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Persist the local service settings selected at install time. */
+export function writeLocalServiceConfig(config) {
+  const path = getLocalServiceConfigPath(config.name);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+function requireLocalServiceConfig(name) {
+  const config = readLocalServiceConfig(name);
+  if (!config) {
+    throw new Error(`Local service not installed for ${name}. Run "yeaft-agent local install --name ${name}" first.`);
+  }
+  return config;
+}
+
+export function generateLocalSystemdUnit(config, options = {}) {
+  const nodePath = getNodePath();
+  const cliPath = options.cliPath || join(dirname(fileURLToPath(import.meta.url)), 'cli.js');
+  const localDataDir = options.dataDir || join(homedir(), '.yeaft', 'server');
+  const yeaftDir = config.yeaftDir || getDefaultYeaftDir(config.name);
+  const logDir = join(getConfigDir(config.name), 'logs');
+  const workingDirectory = options.workingDirectory || dirname(cliPath);
+  const command = [
+    shellQuote(nodePath),
+    shellQuote(cliPath),
+    'local',
+    '--name',
+    shellQuote(config.name),
+    '--port',
+    String(config.port),
+  ].join(' ');
+  return `[Unit]
+Description=Yeaft Local Web UI (${config.name})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${command}
+Restart=on-failure
+RestartSec=5
+WorkingDirectory=${workingDirectory}
+Environment="YEAFT_LOCAL_RUN=true"
+Environment="YEAFT_AGENT_INSTANCE=${systemdEscape(config.name)}"
+Environment="YEAFT_DIR=${systemdEscape(yeaftDir)}"
+Environment="SERVER_DATA_DIR=${systemdEscape(localDataDir)}"
+StandardOutput=append:${logDir}/out.log
+StandardError=append:${logDir}/error.log
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function installLinux(config) {
+  const path = getLocalSystemdServicePath(config.name);
+  const logDir = join(getConfigDir(config.name), 'logs');
+  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(logDir, { recursive: true });
+  writeFileSync(path, generateLocalSystemdUnit(config));
+  execSync('systemctl --user daemon-reload');
+  execSync(`systemctl --user enable --now ${getLocalServiceName(config.name)}`);
+  console.log(`Local service installed and started: ${getLocalServiceName(config.name)}`);
+  console.log(`Open http://127.0.0.1:${config.port}`);
+  console.log(`For boot without an active login session: sudo loginctl enable-linger $(whoami)`);
+}
+
+function uninstallLinux(name) {
+  const serviceName = getLocalServiceName(name);
+  const path = getLocalSystemdServicePath(name);
+  try { execSync(`systemctl --user disable --now ${serviceName}`, { stdio: 'ignore' }); } catch {}
+  if (existsSync(path)) unlinkSync(path);
+  try { execSync('systemctl --user daemon-reload'); } catch {}
+  console.log(`Local service uninstalled: ${serviceName}`);
+}
+
+function controlLinux(command, name) {
+  const serviceName = getLocalServiceName(name);
+  if (command === 'status') {
+    try { execSync(`systemctl --user status ${serviceName} --no-pager`, { stdio: 'inherit' }); } catch {}
+    return;
+  }
+  if (command === 'logs') {
+    execSync(`journalctl --user -u ${serviceName} -f --no-pager -n 100`, { stdio: 'inherit' });
+    return;
+  }
+  execSync(`systemctl --user ${command} ${serviceName}`, { stdio: 'inherit' });
+  const verb = command === 'start' ? 'started'
+    : command === 'stop' ? 'stopped'
+    : command === 'restart' ? 'restarted'
+    : command;
+  console.log(`Local service ${verb}: ${serviceName}`);
+}
+
+export async function handleLocalServiceCommand(command, args = []) {
+  const identity = parseLocalServiceArgs(args);
+  if (platform() !== 'linux') {
+    throw new Error(`Local managed service is currently supported on Linux only (current platform: ${platform()}). Use \`yeaft-agent local --background\` on this platform.`);
+  }
+  if (command === 'install') {
+    const config = parseLocalServiceArgs(args, process.env, {
+      existing: readLocalServiceConfig(identity.name),
+    });
+    writeLocalServiceConfig(config);
+    installLinux(config);
+    return;
+  }
+  if (command === 'uninstall') {
+    uninstallLinux(identity.name);
+    return;
+  }
+  const config = requireLocalServiceConfig(identity.name);
+  controlLinux(command, config.name);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.357",
+  "version": "1.0.359",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/service/config.js

@@ -98,6 +98,10 @@ export function resolveRuntimeIdentity(fileConfig = {}, env = process.env) {
   return { agentName, instanceId };
 }
 
+export function shouldLoadLegacyLocalConfig(env = process.env) {
+  return !String(env.YEAFT_AGENT_INSTANCE || '').trim();
+}
+
 export function resolveServiceInstanceId(args = [], env = process.env, options = {}) {
   const { deprecatedInstanceId, explicitName } = readIdentityArgs(args);
   if (explicitName) return explicitName;
@@ -108,6 +112,19 @@ export function resolveServiceInstanceId(args = [], env = process.env, options =
   return validateInstanceId(options.fallbackName || getDefaultAgentName());
 }
 
+/** Resolve the CLI/env/default Yeaft data root for one Agent instance. */
+export function resolveYeaftDir(args = [], env = process.env, instanceId = DEFAULT_INSTANCE_ID) {
+  let explicitYeaftDir = null;
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== '--yeaft-dir') continue;
+    const value = args[index + 1];
+    if (!value || value.startsWith('-')) throw new Error('--yeaft-dir requires a value');
+    explicitYeaftDir = value;
+    index += 1;
+  }
+  return explicitYeaftDir || env.YEAFT_DIR || getDefaultYeaftDir(instanceId);
+}
+
 /** Legacy alias for resolveServiceInstanceId(). */
 export function getInstanceIdFromArgs(args = [], env = process.env, options = {}) {
   return resolveServiceInstanceId(args, env, options);

package/service/index.js

@@ -29,6 +29,7 @@ export {
   resolveDisplayName,
   resolveRuntimeIdentity,
   resolveServiceInstanceId,
+  shouldLoadLegacyLocalConfig,
   normalizeInstanceId,
   isDefaultInstance,
   validateInstanceId,

package/service.js

@@ -22,6 +22,7 @@ export {
   resolveDisplayName,
   resolveRuntimeIdentity,
   resolveServiceInstanceId,
+  shouldLoadLegacyLocalConfig,
   normalizeInstanceId,
   isDefaultInstance,
   validateInstanceId,