@magclaw/cli-core 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magclaw/cli-core",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Shared local MagClaw CLI implementation used by daemon and computer packages.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -52,6 +52,7 @@ export const CAPABILITIES = [
   'agent:stop',
   'agent:skills:list',
   'daemon:upgrade',
+  'daemon:close',
   'daemon:release_notice',
   'machine:runtime_models:detect',
 ];
@@ -403,6 +404,12 @@ export function profilePaths(profile = DEFAULT_PROFILE, env = process.env) {
   };
 }
 
+function sleepSync(ms) {
+  const timeout = Math.max(0, Number(ms) || 0);
+  if (!timeout) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, timeout);
+}
+
 function machineFingerprintValue() {
   return `mfp_${crypto.createHash('sha256')
     .update([
@@ -585,6 +592,7 @@ function renderHelp() {
     '  --server-url <url>     MagClaw Cloud URL',
     '  --api-key <key>        Machine API key for connect',
     '  --background           Install and run as a background service',
+    '  --disable              With stop: suppress background relaunch until next start',
     '  --bin-dir <path>       install-cli target directory',
     '  --to <version>         Upgrade target version (default: latest)',
     '  --wait-cloud           Wait for Cloud heartbeat during manual upgrade',
@@ -671,6 +679,10 @@ async function readServiceState(profile = DEFAULT_PROFILE, env = process.env) {
     previousPackageSpec: state.previousPackageSpec || '',
     installedDaemonVersion: state.installedDaemonVersion || DAEMON_VERSION,
     installedPackageVersion: state.installedPackageVersion || packageVersion || state.installedDaemonVersion || DAEMON_VERSION,
+    remoteClosed: Boolean(state.remoteClosed),
+    remoteClosedAt: state.remoteClosedAt || '',
+    remoteCloseReason: state.remoteCloseReason || '',
+    remoteCloseCommandId: state.remoteCloseCommandId || '',
     updatedAt: state.updatedAt || '',
   };
 }
@@ -689,6 +701,31 @@ async function writeServiceState(profile = DEFAULT_PROFILE, patch = {}, env = pr
   return next;
 }
 
+async function clearRemoteClosedServiceState(profile = DEFAULT_PROFILE, env = process.env) {
+  return writeServiceState(profile, {
+    remoteClosed: false,
+    remoteClosedAt: '',
+    remoteCloseReason: '',
+    remoteCloseCommandId: '',
+  }, env);
+}
+
+async function markForegroundServiceState(profile = DEFAULT_PROFILE, env = process.env) {
+  const packageInfo = runtimePackageInfo(env);
+  return writeServiceState(profile, {
+    mode: 'foreground',
+    background: false,
+    launcher: 'foreground',
+    packageSpec: packageInfo.spec,
+    packageName: packageInfo.name,
+    packageVersion: packageInfo.version,
+    packageKind: packageInfo.kind,
+    packageBin: packageInfo.bin,
+    installedDaemonVersion: packageInfo.version || DAEMON_VERSION,
+    installedPackageVersion: packageInfo.version || DAEMON_VERSION,
+  }, env);
+}
+
 async function readUpgradeHandoff(profile = DEFAULT_PROFILE, env = process.env) {
   const paths = profilePaths(profile, env);
   const handoff = await readJsonFile(paths.upgradeHandoff, null);
@@ -1185,6 +1222,27 @@ export function toWebSocketUrl(serverUrl, config = {}) {
   if (/^mfp_[a-f0-9]{64}$/i.test(machineFingerprint)) {
     url.searchParams.set('machine_fingerprint', machineFingerprint.toLowerCase());
   }
+  const packageName = String(config.packageName || '').trim();
+  const packageVersion = String(config.packageVersion || config.daemonVersion || '').trim();
+  const packageKind = String(config.packageKind || '').trim();
+  const packageSpec = String(config.packageSpec || '').trim();
+  const packageBin = String(config.packageBin || '').trim();
+  const cliCoreVersion = String(config.cliCoreVersion || '').trim();
+  const serviceMode = String(config.serviceMode || '').trim();
+  const serviceBackground = Boolean(config.serviceBackground);
+  const serviceActive = Boolean(config.serviceActive);
+  if (packageName) url.searchParams.set('package_name', packageName);
+  if (packageVersion) {
+    url.searchParams.set('package_version', packageVersion);
+    url.searchParams.set('daemon_version', packageVersion);
+  }
+  if (packageKind) url.searchParams.set('package_kind', packageKind);
+  if (packageSpec) url.searchParams.set('package_spec', packageSpec);
+  if (packageBin) url.searchParams.set('package_bin', packageBin);
+  if (cliCoreVersion) url.searchParams.set('cli_core_version', cliCoreVersion);
+  if (serviceMode) url.searchParams.set('service_mode', serviceMode);
+  url.searchParams.set('service_background', String(serviceBackground));
+  url.searchParams.set('service_active', String(serviceActive));
   return url;
 }
 
@@ -3096,6 +3154,12 @@ class ClaudeAgentSession {
   }
 }
 
+function readOnlySessionAckStatus(session) {
+  const status = String(session?.status || '').toLowerCase();
+  if ((!status || status === 'offline') && !session?.started) return 'idle';
+  return session?.status || 'idle';
+}
+
 class MagClawDaemon {
   constructor(config, env = process.env) {
     this.env = env;
@@ -3452,6 +3516,47 @@ class MagClawDaemon {
     await this.startUpgradeWorker(message);
   }
 
+  async handleDaemonClose(message) {
+    const commandId = String(message.commandId || '').trim();
+    const service = await readServiceState(this.paths.profile, this.env);
+    const serviceStatus = backgroundServiceStatus(this.paths.profile, this.env);
+    const packageInfo = runtimePackageInfo(this.env, service);
+    const runMode = {
+      mode: service.mode || serviceStatus.mode || 'foreground',
+      background: Boolean(service.background),
+      active: Boolean(serviceStatus.active),
+      label: serviceStatus.label || '',
+      serviceName: serviceStatus.serviceName || '',
+      taskName: serviceStatus.taskName || '',
+      packageName: packageInfo.name,
+      packageVersion: packageInfo.version,
+      packageKind: packageInfo.kind,
+      packageSpec: packageInfo.spec,
+      packageBin: packageInfo.bin,
+    };
+    logWarning('daemon', `Remote close requested (${message.reason || 'closed_from_cloud'}).`);
+    await writeServiceState(this.paths.profile, {
+      remoteClosed: true,
+      remoteClosedAt: now(),
+      remoteCloseReason: message.reason || 'closed_from_cloud',
+      remoteCloseCommandId: commandId,
+    }, this.env);
+    for (const session of this.sessions.values()) session.stop();
+    this.sessions.clear();
+    this.send({ type: 'daemon:close:ack',
+      commandId,
+      status: 'stopping',
+      reason: message.reason || 'closed_from_cloud',
+      service: runMode,
+      at: now(),
+    });
+    const background = stopBackground(this.paths.profile, this.env, { disable: message.disableBackground !== false });
+    logInfo('daemon', `Close request stopped background service mode=${background.mode || 'foreground'} ok=${Boolean(background.ok)}.`);
+    this.close();
+    process.exitCode = 0;
+    setTimeout(() => process.exit(0), 50).unref?.();
+  }
+
   async readyPayload() {
     const runtimes = await detectRuntimes(this.env);
     const owner = await ensureMachineFingerprint(this.paths.profile, this.env);
@@ -3657,6 +3762,9 @@ class MagClawDaemon {
       case 'daemon:upgrade':
         await this.handleDaemonUpgrade(message);
         break;
+      case 'daemon:close':
+        await this.handleDaemonClose(message);
+        break;
       case 'agent:start':
         await this.handleAgentStart(message);
         break;
@@ -3706,7 +3814,7 @@ class MagClawDaemon {
         ? await session.listSkills()
         : { agent: { id: agent.id, name: agent.name || agent.id }, global: [], workspace: [], plugin: [], tools: [] };
       this.send({ type: 'agent:skills:list_result', commandId: message.commandId, agentId: agent.id, skills });
-      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: agent.id, status: session.status || 'idle' });
+      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: agent.id, status: readOnlySessionAckStatus(session) });
     } catch (error) {
       this.send({ type: 'agent:skills:list_result', commandId: message.commandId, agentId: agent.id, skills: { agent: { id: agent.id, name: agent.name || agent.id }, global: [], workspace: [], plugin: [], tools: [], error: error.message } });
       this.send({ type: 'agent:error', commandId: message.commandId, agentId: agent.id, error: error.message });
@@ -3731,7 +3839,7 @@ class MagClawDaemon {
       const session = await this.sessionForWorkspaceRequest(message);
       const tree = await session.listWorkspace(message.path || message.payload?.path || '');
       this.send({ type: 'agent:workspace:list_result', commandId: message.commandId, agentId: session.agent.id, tree });
-      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: session.agent.id, status: session.status || 'idle' });
+      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: session.agent.id, status: readOnlySessionAckStatus(session) });
     } catch (error) {
       this.send({ type: 'agent:error', commandId: message.commandId, agentId: message.agentId || null, error: error.message });
     }
@@ -3742,7 +3850,7 @@ class MagClawDaemon {
       const session = await this.sessionForWorkspaceRequest(message);
       const file = await session.readWorkspaceFile(message.path || message.payload?.path || 'MEMORY.md');
       this.send({ type: 'agent:workspace:file_result', commandId: message.commandId, agentId: session.agent.id, file: file.file });
-      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: session.agent.id, status: session.status || 'idle' });
+      this.send({ type: 'agent:ack', commandId: message.commandId, agentId: session.agent.id, status: readOnlySessionAckStatus(session) });
     } catch (error) {
       this.send({ type: 'agent:error', commandId: message.commandId, agentId: message.agentId || null, error: error.message });
     }
@@ -3992,11 +4100,26 @@ class MagClawDaemon {
   async connectOnce() {
     if (this.closed) return;
     await this.refreshConfigFromDisk();
-    const url = toWebSocketUrl(this.config.serverUrl, this.config);
+    const service = await readServiceState(this.paths.profile, this.env);
+    const serviceStatus = backgroundServiceStatus(this.paths.profile, this.env);
+    const packageInfo = runtimePackageInfo(this.env, service);
+    const url = toWebSocketUrl(this.config.serverUrl, {
+      ...this.config,
+      packageName: packageInfo.name,
+      packageVersion: packageInfo.version,
+      packageKind: packageInfo.kind,
+      packageSpec: packageInfo.spec,
+      packageBin: packageInfo.bin,
+      cliCoreVersion: CLI_CORE_VERSION,
+      serviceMode: service.mode || serviceStatus.mode || 'foreground',
+      serviceBackground: Boolean(service.background),
+      serviceActive: Boolean(serviceStatus.active),
+    });
     const requestModule = url.protocol === 'wss:' ? https : http;
     const requestUrl = new URL(url.href.replace(/^ws/, 'http'));
     const key = crypto.randomBytes(16).toString('base64');
-    logInfo('daemon', `Connecting MagClaw daemon profile "${this.paths.profile}" to ${this.config.serverUrl}...`);
+    logInfo('daemon', `Connecting MagClaw daemon v${packageInfo.version || DAEMON_VERSION} profile "${this.paths.profile}" to ${this.config.serverUrl}...`);
+    if (this.closed) return;
     return new Promise((resolve, reject) => {
       let settled = false;
       const finish = (callback, value) => {
@@ -4176,6 +4299,10 @@ async function writeLauncher(profile, env = process.env) {
     installedDaemonVersion: packageVersion || DAEMON_VERSION,
     installedPackageVersion: packageVersion || DAEMON_VERSION,
     commandMode: useNpmLauncher ? 'npm' : 'local',
+    remoteClosed: false,
+    remoteClosedAt: '',
+    remoteCloseReason: '',
+    remoteCloseCommandId: '',
   }, env);
   const code = [
     '#!/usr/bin/env node',
@@ -4192,6 +4319,11 @@ async function writeLauncher(profile, env = process.env) {
     `const defaultPackageSpec = ${JSON.stringify(service.packageSpec)};`,
     "let service = {};",
     "try { service = JSON.parse(fs.readFileSync(serviceFile, 'utf8')); } catch {}",
+    "if (service.remoteClosed) {",
+    "  const stamp = new Date().toISOString().replace('T', ' ').slice(0, 19);",
+    "  console.error(`${stamp} INFO DAEMON profile ${profile} is closed from MagClaw Cloud; run magclaw start/restart/connect to reconnect.`);",
+    "  process.exit(0);",
+    "}",
     "const packageSpec = String(service.packageSpec || defaultPackageSpec || '@magclaw/daemon@latest');",
     "const packageName = String(service.packageName || (packageSpec.startsWith('@magclaw/computer@') || packageSpec === '@magclaw/computer' ? '@magclaw/computer' : '@magclaw/daemon'));",
     "const packageKind = String(service.packageKind || (packageName === '@magclaw/computer' ? 'computer' : 'daemon'));",
@@ -4285,6 +4417,7 @@ async function startMacBackground(profile, env = process.env) {
   ].join('\n');
   await writeFile(plist, xml);
   spawnSync('launchctl', ['bootout', `gui/${process.getuid()}`, plist], { stdio: 'ignore' });
+  spawnSync('launchctl', ['enable', `gui/${process.getuid()}/${label}`], { stdio: 'ignore' });
   const boot = spawnSync('launchctl', ['bootstrap', `gui/${process.getuid()}`, plist], { encoding: 'utf8' });
   if (boot.status !== 0) {
     const load = spawnSync('launchctl', ['load', plist], { encoding: 'utf8' });
@@ -4403,6 +4536,29 @@ function backgroundServiceStatus(profile, env = process.env) {
   return { mode: 'foreground', active: false };
 }
 
+function launchctlResultIsNotLoaded(result) {
+  const detail = String(result?.stderr || result?.stdout || '').toLowerCase();
+  return detail.includes('no such process') || detail.includes('could not find service') || detail.includes('not found');
+}
+
+function launchctlServiceIsStopped(serviceTarget) {
+  const result = spawnSync('launchctl', ['print', serviceTarget], { encoding: 'utf8' });
+  if (result.status !== 0) return launchctlResultIsNotLoaded(result);
+  const output = String(result.stdout || result.stderr || '');
+  if (/\bstate\s*=\s*running\b/i.test(output)) return false;
+  if (/\bpid\s*=\s*[1-9][0-9]*\b/i.test(output)) return false;
+  return true;
+}
+
+function waitForBackgroundServiceStopped(serviceTarget, timeoutMs = 2000) {
+  const deadline = Date.now() + Math.max(250, Number(timeoutMs) || 2000);
+  while (Date.now() < deadline) {
+    if (launchctlServiceIsStopped(serviceTarget)) return true;
+    sleepSync(100);
+  }
+  return launchctlServiceIsStopped(serviceTarget);
+}
+
 async function waitForPidExit(pid, timeoutMs = 2000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -4451,32 +4607,58 @@ async function stopActiveDaemon(profile, env = process.env) {
   return { ok: stopped, running: !stopped, pid, signal };
 }
 
-function stopBackground(profile, env = process.env) {
+function stopBackground(profile, env = process.env, options = {}) {
   if (process.platform === 'darwin') {
     const paths = profilePaths(profile, env);
     const label = launchAgentLabel(paths.profile);
+    const serviceTarget = `gui/${process.getuid()}/${label}`;
     const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
-    spawnSync('launchctl', ['bootout', `gui/${process.getuid()}`, plist], { stdio: 'ignore' });
-    return { ok: true, mode: 'launchd', label, file: plist };
+    if (options.disable) {
+      const disabled = spawnSync('launchctl', ['disable', serviceTarget], { encoding: 'utf8' });
+      const stopped = spawnSync('launchctl', ['stop', label], { encoding: 'utf8' });
+      const stoppedConfirmed = stopped.status === 0 && waitForBackgroundServiceStopped(serviceTarget);
+      const needsBootout = disabled.status !== 0 || !stoppedConfirmed;
+      const bootout = needsBootout
+        ? spawnSync('launchctl', ['bootout', serviceTarget], { encoding: 'utf8' })
+        : null;
+      const bootoutOk = bootout ? (bootout.status === 0 || launchctlResultIsNotLoaded(bootout)) : false;
+      if (stopped.status !== 0) spawnSync('launchctl', ['bootout', `gui/${process.getuid()}`, plist], { stdio: 'ignore' });
+      return {
+        ok: disabled.status === 0 && (stoppedConfirmed || bootoutOk),
+        mode: 'launchd',
+        label,
+        serviceTarget,
+        file: plist,
+        disabled: disabled.status === 0,
+        stopped: stoppedConfirmed || bootoutOk,
+        bootout: bootout ? bootout.status === 0 : false,
+        error: disabled.status === 0 && (stoppedConfirmed || bootoutOk) ? '' : String(bootout?.stderr || stopped.stderr || disabled.stderr || bootout?.stdout || stopped.stdout || disabled.stdout || '').trim(),
+      };
+    }
+    const bootout = spawnSync('launchctl', ['bootout', serviceTarget], { encoding: 'utf8' });
+    return { ok: bootout.status === 0 || launchctlResultIsNotLoaded(bootout), mode: 'launchd', label, serviceTarget, file: plist, error: bootout.stderr || bootout.stdout || '' };
   }
   if (process.platform === 'linux') {
     const paths = profilePaths(profile, env);
     const serviceName = systemdServiceName(paths.profile);
-    const result = spawnSync('systemctl', ['--user', 'disable', '--now', serviceName], { encoding: 'utf8' });
+    const result = options.disable
+      ? spawnSync('systemctl', ['--user', 'disable', '--now', serviceName], { encoding: 'utf8' })
+      : spawnSync('systemctl', ['--user', 'stop', serviceName], { encoding: 'utf8' });
     return { ok: result.status === 0, mode: 'systemd', serviceName, error: result.stderr || '' };
   }
   if (process.platform === 'win32') {
     const paths = profilePaths(profile, env);
     const taskName = windowsTaskName(paths.profile);
     spawnSync('schtasks.exe', ['/End', '/TN', taskName], { stdio: 'ignore' });
+    if (!options.disable) return { ok: true, mode: 'schtasks', taskName };
     const result = spawnSync('schtasks.exe', ['/Change', '/TN', taskName, '/DISABLE'], { encoding: 'utf8' });
     return { ok: result.status === 0, mode: 'schtasks', taskName, error: result.stderr || result.stdout || '' };
   }
   return { ok: false, mode: 'foreground' };
 }
 
-async function stopDaemon(profile, env = process.env) {
-  const background = stopBackground(profile, env);
+async function stopDaemon(profile, env = process.env, options = {}) {
+  const background = stopBackground(profile, env, options);
   const processResult = await stopActiveDaemon(profile, env);
   const backgroundRequired = background.mode !== 'foreground';
   return {
@@ -5081,6 +5263,7 @@ async function runComputerSetup(flags, env = process.env) {
     fingerprint: owner.fingerprint,
   }, env);
   await saveProfile(config.profile, config, env);
+  await clearRemoteClosedServiceState(config.profile, env);
   const cli = await tryInstallCliShim(flags, env);
   const result = await startBackground(config.profile, env);
   printJson({
@@ -5119,6 +5302,7 @@ async function buildConfig(flags, env = process.env) {
 
 async function runForegroundDaemon(config, env = process.env) {
   const releaseLock = await acquireDaemonLock(config.profile, config, env);
+  await markForegroundServiceState(config.profile, env);
   const daemon = new MagClawDaemon(config, env);
   let forceExitTimer = null;
   const shutdown = (signal) => {
@@ -5145,6 +5329,7 @@ async function runConnect(flags, env = process.env) {
     throw new Error('Run connect with --api-key, --pair-token for legacy pairing, or use a saved profile with a machine token.');
   }
   await saveProfile(config.profile, config, env);
+  await clearRemoteClosedServiceState(config.profile, env);
   const cli = await tryInstallCliShim(flags, env);
   if (flags.background) {
     const result = await startBackground(config.profile, env);
@@ -5211,7 +5396,7 @@ export async function main(argv = process.argv, env = process.env) {
     }
     case 'stop':
       requireExplicitProfile('stop', flags);
-      printJson(await stopDaemon(flags.profile, env));
+      printJson(await stopDaemon(flags.profile, env, { disable: Boolean(flags.disable) }));
       break;
     case 'restart':
       printJson(await restartSavedBackground(flags, env));