@magclaw/cli-core 0.1.22 → 0.1.24

package/package.json

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

package/src/cli.js

@@ -39,6 +39,10 @@ const PACKAGE_JSON = (() => {
   }
 })();
 export const DAEMON_VERSION = String(PACKAGE_JSON.version || '0.0.0');
+export const CLI_CORE_VERSION = DAEMON_VERSION;
+const DAEMON_PACKAGE_NAME = '@magclaw/daemon';
+const COMPUTER_PACKAGE_NAME = '@magclaw/computer';
+const KNOWN_ENTRY_PACKAGE_NAMES = new Set([DAEMON_PACKAGE_NAME, COMPUTER_PACKAGE_NAME]);
 const SOURCE_CODEX_HOME = path.resolve(process.env.MAGCLAW_CODEX_HOME_SOURCE || process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
 const CODEX_HOME_SHARED_ENTRIES = ['auth.json', 'plugins', 'vendor_imports'];
 export const CAPABILITIES = [
@@ -48,6 +52,7 @@ export const CAPABILITIES = [
   'agent:stop',
   'agent:skills:list',
   'daemon:upgrade',
+  'daemon:close',
   'daemon:release_notice',
   'machine:runtime_models:detect',
 ];
@@ -56,6 +61,71 @@ function now() {
   return new Date().toISOString();
 }
 
+function packageInfoFromSpec(packageSpec = '') {
+  const match = String(packageSpec || '').trim().match(/^(@magclaw\/(?:daemon|computer))(?:@(.+))?$/);
+  return {
+    name: match?.[1] || '',
+    version: match?.[2] || '',
+  };
+}
+
+function normalizeEntryPackageName(value = '', fallback = DAEMON_PACKAGE_NAME) {
+  const clean = String(value || '').trim();
+  if (KNOWN_ENTRY_PACKAGE_NAMES.has(clean)) return clean;
+  return fallback;
+}
+
+function packageKindForPackageName(packageName = '') {
+  return normalizeEntryPackageName(packageName) === COMPUTER_PACKAGE_NAME ? 'computer' : 'daemon';
+}
+
+function packageBinForPackageName(packageName = '') {
+  return packageKindForPackageName(packageName) === 'computer' ? 'magclaw-computer' : 'magclaw';
+}
+
+function packageSpecForPackageName(packageName = DAEMON_PACKAGE_NAME, version = 'latest') {
+  const name = normalizeEntryPackageName(packageName);
+  const cleanVersion = String(version || '').trim() || 'latest';
+  return cleanVersion === 'latest' ? `${name}@latest` : `${name}@${cleanVersion}`;
+}
+
+function runtimePackageInfo(env = process.env, service = {}) {
+  const envSpec = String(env.MAGCLAW_DAEMON_PACKAGE_SPEC || '').trim();
+  const serviceSpec = String(service.packageSpec || '').trim();
+  const parsed = packageInfoFromSpec(envSpec || serviceSpec);
+  const packageName = normalizeEntryPackageName(
+    env.MAGCLAW_ENTRY_PACKAGE_NAME
+      || env.MAGCLAW_DAEMON_PACKAGE_NAME
+      || service.packageName
+      || parsed.name,
+  );
+  const packageVersion = String(
+    env.MAGCLAW_ENTRY_PACKAGE_VERSION
+      || env.MAGCLAW_DAEMON_PACKAGE_VERSION
+      || service.packageVersion
+      || parsed.version
+      || DAEMON_VERSION,
+  ).trim();
+  const packageKind = String(
+    env.MAGCLAW_DAEMON_PACKAGE_KIND
+      || service.packageKind
+      || packageKindForPackageName(packageName),
+  ).trim().toLowerCase() === 'computer' ? 'computer' : 'daemon';
+  const packageBin = String(
+    env.MAGCLAW_DAEMON_PACKAGE_BIN
+      || service.packageBin
+      || packageBinForPackageName(packageName),
+  ).trim() || packageBinForPackageName(packageName);
+  const packageSpec = envSpec || serviceSpec || packageSpecForPackageName(packageName, packageVersion || 'latest');
+  return {
+    name: packageName,
+    version: packageVersion,
+    kind: packageKind,
+    bin: packageBin,
+    spec: packageSpec,
+  };
+}
+
 function localTimestamp(date = new Date()) {
   const pad = (value) => String(value).padStart(2, '0');
   return [
@@ -516,6 +586,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',
@@ -584,17 +655,25 @@ async function saveProfile(profile, config, env = process.env) {
 async function readServiceState(profile = DEFAULT_PROFILE, env = process.env) {
   const paths = profilePaths(profile, env);
   const state = await readJsonFile(paths.service, {});
+  const parsed = packageInfoFromSpec(state.packageSpec || '');
+  const packageName = normalizeEntryPackageName(state.packageName || parsed.name || DAEMON_PACKAGE_NAME);
+  const packageVersion = String(state.packageVersion || parsed.version || state.installedPackageVersion || state.installedDaemonVersion || '').trim();
   return {
+    ...state,
     version: 1,
     profile: paths.profile,
     mode: state.mode || 'foreground',
     background: Boolean(state.background),
     launcher: state.launcher || '',
     packageSpec: state.packageSpec || '',
+    packageName,
+    packageVersion,
+    packageKind: String(state.packageKind || packageKindForPackageName(packageName)).toLowerCase() === 'computer' ? 'computer' : 'daemon',
+    packageBin: state.packageBin || packageBinForPackageName(packageName),
     previousPackageSpec: state.previousPackageSpec || '',
     installedDaemonVersion: state.installedDaemonVersion || DAEMON_VERSION,
+    installedPackageVersion: state.installedPackageVersion || packageVersion || state.installedDaemonVersion || DAEMON_VERSION,
     updatedAt: state.updatedAt || '',
-    ...state,
   };
 }
 
@@ -3232,6 +3311,9 @@ class MagClawDaemon {
     this.upgradeWorkerStarting = true;
     const targetVersion = String(message.targetVersion || message.version || 'latest').trim() || 'latest';
     const previousVersion = String(message.previousVersion || DAEMON_VERSION).trim() || DAEMON_VERSION;
+    const packageName = normalizeEntryPackageName(message.packageName || packageInfoFromSpec(message.packageSpec || '').name || this.env.MAGCLAW_ENTRY_PACKAGE_NAME || this.env.MAGCLAW_DAEMON_PACKAGE_NAME);
+    const packageKind = packageKindForPackageName(packageName);
+    const packageBin = String(message.packageBin || packageBinForPackageName(packageName)).trim() || packageBinForPackageName(packageName);
     const service = await readServiceState(this.paths.profile, this.env);
     const activeService = backgroundServiceStatus(this.paths.profile, this.env);
     if (!service.background || !activeService.active) {
@@ -3245,6 +3327,10 @@ class MagClawDaemon {
         message: error,
         previousVersion,
         targetVersion,
+        packageName,
+        packageKind,
+        packageBin,
+        packageSpec: message.packageSpec || packageSpecForPackageName(packageName, targetVersion),
         error,
         service: activeService,
       }, this.env);
@@ -3257,6 +3343,9 @@ class MagClawDaemon {
         message: error,
         previousVersion,
         targetVersion,
+        packageName,
+        packageKind,
+        packageBin,
       });
       this.upgradeWorkerStarting = false;
       return false;
@@ -3270,7 +3359,10 @@ class MagClawDaemon {
       message: 'Upgrade worker is starting.',
       previousVersion,
       targetVersion,
-      packageSpec: message.packageSpec || '',
+      packageName,
+      packageKind,
+      packageBin,
+      packageSpec: message.packageSpec || packageSpecForPackageName(packageName, targetVersion),
       startedAt: now(),
     }, this.env);
     this.send({
@@ -3281,6 +3373,9 @@ class MagClawDaemon {
       progress: 1,
       previousVersion,
       targetVersion,
+      packageName,
+      packageKind,
+      packageBin,
       message: 'Upgrade worker is starting.',
     });
     const args = [
@@ -3296,6 +3391,8 @@ class MagClawDaemon {
       previousVersion,
     ];
     if (message.packageSpec) args.push('--package-spec', String(message.packageSpec));
+    args.push('--package-name', packageName);
+    args.push('--package-bin', packageBin);
     const child = spawn(process.execPath, args, {
       cwd: process.cwd(),
       detached: true,
@@ -3315,6 +3412,9 @@ class MagClawDaemon {
     const commandId = String(message.commandId || '').trim();
     const targetVersion = String(message.targetVersion || message.version || 'latest').trim() || 'latest';
     const previousVersion = String(message.previousVersion || DAEMON_VERSION).trim() || DAEMON_VERSION;
+    const packageName = normalizeEntryPackageName(message.packageName || packageInfoFromSpec(message.packageSpec || '').name || this.env.MAGCLAW_ENTRY_PACKAGE_NAME || this.env.MAGCLAW_DAEMON_PACKAGE_NAME);
+    const packageKind = packageKindForPackageName(packageName);
+    const packageBin = String(message.packageBin || packageBinForPackageName(packageName)).trim() || packageBinForPackageName(packageName);
     if (!commandId) {
       this.send({ type: 'daemon:upgrade:ack', status: 'failed', error: 'Missing commandId.' });
       return;
@@ -3327,7 +3427,10 @@ class MagClawDaemon {
       message: this.daemonIsIdleForUpgrade() ? 'Daemon accepted upgrade command.' : 'Waiting for all Agent work to become idle.',
       previousVersion,
       targetVersion,
-      packageSpec: message.packageSpec || '',
+      packageName,
+      packageKind,
+      packageBin,
+      packageSpec: message.packageSpec || packageSpecForPackageName(packageName, targetVersion),
       requestedAt: now(),
     }, this.env);
     if (!this.daemonIsIdleForUpgrade()) {
@@ -3340,6 +3443,9 @@ class MagClawDaemon {
         progress: 0,
         previousVersion,
         targetVersion,
+        packageName,
+        packageKind,
+        packageBin,
         message: 'Waiting for all Agent work to become idle.',
       });
       this.scheduleUpgradeIdleCheck();
@@ -3348,12 +3454,48 @@ 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'}).`);
+    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);
     const service = await readServiceState(this.paths.profile, this.env);
     const serviceStatus = backgroundServiceStatus(this.paths.profile, this.env);
     const upgrade = await readUpgradeHandoff(this.paths.profile, this.env);
+    const packageInfo = runtimePackageInfo(this.env, service);
     return {
       type: 'ready',
       computerId: this.config.computerId || null,
@@ -3363,7 +3505,13 @@ class MagClawDaemon {
       hostname: os.hostname(),
       os: `${os.platform()} ${os.release()}`,
       arch: os.arch(),
-      daemonVersion: DAEMON_VERSION,
+      daemonVersion: packageInfo.version || DAEMON_VERSION,
+      packageName: packageInfo.name,
+      packageVersion: packageInfo.version,
+      packageKind: packageInfo.kind,
+      packageSpec: packageInfo.spec,
+      packageBin: packageInfo.bin,
+      cliCoreVersion: CLI_CORE_VERSION,
       service: {
         mode: service.mode || serviceStatus.mode || 'foreground',
         background: Boolean(service.background),
@@ -3372,7 +3520,12 @@ class MagClawDaemon {
         serviceName: serviceStatus.serviceName || '',
         taskName: serviceStatus.taskName || '',
         launcher: service.launcher || '',
-        packageSpec: service.packageSpec || '',
+        packageSpec: service.packageSpec || packageInfo.spec || '',
+        packageName: service.packageName || packageInfo.name,
+        packageVersion: service.packageVersion || packageInfo.version,
+        packageKind: service.packageKind || packageInfo.kind,
+        packageBin: service.packageBin || packageInfo.bin,
+        cliCoreVersion: CLI_CORE_VERSION,
       },
       upgrade: upgrade || null,
       runtimes: runtimes.filter((runtime) => runtime.installed).map((runtime) => runtime.id),
@@ -3392,11 +3545,18 @@ class MagClawDaemon {
   }
 
   sendHeartbeat() {
+    const packageInfo = runtimePackageInfo(this.env);
     const sent = this.send({
       type: 'heartbeat',
       time: now(),
       computerId: this.config.computerId || null,
-      daemonVersion: DAEMON_VERSION,
+      daemonVersion: packageInfo.version || DAEMON_VERSION,
+      packageName: packageInfo.name,
+      packageVersion: packageInfo.version,
+      packageKind: packageInfo.kind,
+      packageSpec: packageInfo.spec,
+      packageBin: packageInfo.bin,
+      cliCoreVersion: CLI_CORE_VERSION,
       runningAgents: [...this.sessions.keys()],
     });
     logInfo('daemon', `Sent heartbeat (runningAgents=${this.sessions.size}, sent=${sent}).`);
@@ -3534,6 +3694,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;
@@ -3873,7 +4036,9 @@ class MagClawDaemon {
     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}...`);
+    const packageInfo = runtimePackageInfo(this.env);
+    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) => {
@@ -4020,13 +4185,38 @@ async function writeLauncher(profile, env = process.env) {
   const launcher = path.join(paths.runDir, 'launcher.js');
   const fallbackBin = executablePath();
   const previousService = await readServiceState(paths.profile, env);
+  const preferPersistedPackage = Boolean(previousService.pendingCommandId);
+  const envPackageInfo = runtimePackageInfo(env, {});
+  const persistedPackageInfo = runtimePackageInfo({}, previousService);
+  const packageInfo = preferPersistedPackage ? persistedPackageInfo : runtimePackageInfo(env, previousService);
+  const packageSpec = preferPersistedPackage
+    ? (previousService.packageSpec || persistedPackageInfo.spec)
+    : (env.MAGCLAW_DAEMON_PACKAGE_SPEC || previousService.packageSpec || packageInfo.spec || packageSpecForPackageName(packageInfo.name, 'latest'));
+  const packageName = normalizeEntryPackageName(
+    packageInfoFromSpec(packageSpec).name
+      || packageInfo.name
+      || envPackageInfo.name
+      || previousService.packageName,
+  );
+  const packageVersion = String(packageInfoFromSpec(packageSpec).version || packageInfo.version || previousService.packageVersion || '').trim();
+  const packageKind = packageKindForPackageName(packageName);
+  const packageBin = String(
+    (preferPersistedPackage ? previousService.packageBin : env.MAGCLAW_DAEMON_PACKAGE_BIN)
+      || previousService.packageBin
+      || packageBinForPackageName(packageName),
+  ).trim() || packageBinForPackageName(packageName);
   const service = await writeServiceState(paths.profile, {
     mode: process.platform === 'darwin' ? 'launchd' : process.platform === 'linux' ? 'systemd' : process.platform === 'win32' ? 'schtasks' : 'foreground',
     background: true,
     launcher,
-    packageSpec: env.MAGCLAW_DAEMON_PACKAGE_SPEC || previousService.packageSpec || '@magclaw/daemon@latest',
+    packageSpec,
+    packageName,
+    packageVersion,
+    packageKind,
+    packageBin,
     previousPackageSpec: previousService.previousPackageSpec || '',
-    installedDaemonVersion: DAEMON_VERSION,
+    installedDaemonVersion: packageVersion || DAEMON_VERSION,
+    installedPackageVersion: packageVersion || DAEMON_VERSION,
     commandMode: useNpmLauncher ? 'npm' : 'local',
   }, env);
   const code = [
@@ -4045,14 +4235,31 @@ async function writeLauncher(profile, env = process.env) {
     "let service = {};",
     "try { service = JSON.parse(fs.readFileSync(serviceFile, 'utf8')); } catch {}",
     "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'));",
+    "const packageBin = String(service.packageBin || (packageKind === 'computer' ? 'magclaw-computer' : 'magclaw'));",
+    "const packageVersionMatch = packageSpec.match(/^@magclaw\\/(?:daemon|computer)@(.+)$/);",
+    "const packageVersion = String(service.packageVersion || (packageVersionMatch ? packageVersionMatch[1] : ''));",
     'const command = useNpmLauncher ? npmPath : process.execPath;',
     "const args = useNpmLauncher",
-    "  ? ['exec', '--yes', '--package', packageSpec, '--', 'magclaw', 'connect', '--profile', profile]",
+    "  ? ['exec', '--yes', '--package', packageSpec, '--', packageBin, 'connect', '--profile', profile]",
     "  : [fallbackBin, 'connect', '--profile', profile];",
     "const launchPath = [nodeDir, npmDir, process.env.PATH || '/usr/bin:/bin:/usr/sbin:/sbin'].filter(Boolean).join(':');",
+    "const childEnv = {",
+    "  ...process.env,",
+    "  MAGCLAW_DAEMON_HOME: daemonHome,",
+    "  MAGCLAW_ENTRY_PACKAGE_NAME: packageName,",
+    "  MAGCLAW_ENTRY_PACKAGE_VERSION: packageVersion,",
+    "  MAGCLAW_DAEMON_PACKAGE_NAME: packageName,",
+    "  MAGCLAW_DAEMON_PACKAGE_SPEC: packageSpec,",
+    "  MAGCLAW_DAEMON_PACKAGE_KIND: packageKind,",
+    "  MAGCLAW_DAEMON_PACKAGE_BIN: packageBin,",
+    "  PATH: launchPath,",
+    "};",
+    "if (packageKind === 'computer') childEnv.MAGCLAW_COMPUTER_DAEMON = '1';",
     'const child = spawn(command, args, {',
     "  stdio: 'inherit',",
-    '  env: { ...process.env, MAGCLAW_DAEMON_HOME: daemonHome, PATH: launchPath },',
+    '  env: childEnv,',
     '});',
     "child.on('exit', (code, signal) => {",
     '  if (signal) process.kill(process.pid, signal);',
@@ -4120,6 +4327,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' });
@@ -4286,32 +4494,49 @@ 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 plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+    if (options.disable) {
+      const disabled = spawnSync('launchctl', ['disable', `gui/${process.getuid()}/${label}`], { encoding: 'utf8' });
+      const stopped = spawnSync('launchctl', ['stop', label], { encoding: 'utf8' });
+      if (stopped.status !== 0) spawnSync('launchctl', ['bootout', `gui/${process.getuid()}`, plist], { stdio: 'ignore' });
+      return {
+        ok: disabled.status === 0 || stopped.status === 0,
+        mode: 'launchd',
+        label,
+        file: plist,
+        disabled: disabled.status === 0,
+        stopped: stopped.status === 0,
+        error: disabled.status === 0 && stopped.status === 0 ? '' : String(stopped.stderr || disabled.stderr || stopped.stdout || disabled.stdout || '').trim(),
+      };
+    }
     spawnSync('launchctl', ['bootout', `gui/${process.getuid()}`, plist], { stdio: 'ignore' });
     return { ok: true, mode: 'launchd', label, file: plist };
   }
   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 {
@@ -4573,13 +4798,24 @@ async function openUpgradeProgressSocket(url) {
 function packageSpecForUpgrade(targetVersion, flags = {}, env = process.env) {
   const explicit = String(flags.packageSpec || env.MAGCLAW_DAEMON_UPGRADE_PACKAGE_SPEC || '').trim();
   if (explicit) return explicit;
+  const packageName = normalizeEntryPackageName(
+    flags.packageName
+      || flags.package
+      || env.MAGCLAW_DAEMON_UPGRADE_PACKAGE_NAME
+      || env.MAGCLAW_ENTRY_PACKAGE_NAME
+      || env.MAGCLAW_DAEMON_PACKAGE_NAME
+      || packageInfoFromSpec(env.MAGCLAW_DAEMON_PACKAGE_SPEC || '').name,
+  );
   const target = String(targetVersion || '').trim();
-  return target && target !== 'latest' ? `@magclaw/daemon@${target}` : '@magclaw/daemon@latest';
+  return packageSpecForPackageName(packageName, target && target !== 'latest' ? target : 'latest');
 }
 
 function npmPackageLooksRemote(packageSpec) {
   const value = String(packageSpec || '').trim();
-  return value.startsWith('@magclaw/daemon@') || value === '@magclaw/daemon';
+  return value.startsWith('@magclaw/daemon@')
+    || value === '@magclaw/daemon'
+    || value.startsWith('@magclaw/computer@')
+    || value === '@magclaw/computer';
 }
 
 function preflightPackage(packageSpec, env = process.env) {
@@ -4642,12 +4878,15 @@ async function runUpgradeWorker(flags, env = process.env) {
   const targetVersion = String(flags.targetVersion || flags.version || flags.to || flags.tag || 'latest').trim() || 'latest';
   const previousVersion = String(flags.previousVersion || DAEMON_VERSION).trim() || DAEMON_VERSION;
   const packageSpec = packageSpecForUpgrade(targetVersion, flags, env);
+  const packageName = normalizeEntryPackageName(packageInfoFromSpec(packageSpec).name || flags.packageName || env.MAGCLAW_ENTRY_PACKAGE_NAME || env.MAGCLAW_DAEMON_PACKAGE_NAME);
+  const packageKind = packageKindForPackageName(packageName);
+  const packageBin = String(flags.packageBin || env.MAGCLAW_DAEMON_UPGRADE_PACKAGE_BIN || packageBinForPackageName(packageName)).trim() || packageBinForPackageName(packageName);
   const progressIntervalMs = Math.max(100, Math.min(5000, Number(flags.progressIntervalMs || env.MAGCLAW_DAEMON_UPGRADE_PROGRESS_MS || 500) || 500));
   const readyTimeoutMs = Math.max(5000, Math.min(10 * 60_000, Number(flags.readyTimeoutMs || env.MAGCLAW_DAEMON_UPGRADE_READY_TIMEOUT_MS || 120_000) || 120_000));
   const localOnly = Boolean(flags.localOnly || flags.local || flags.noWaitCloud);
   const assumeReady = Boolean(flags.assumeReady || env.MAGCLAW_DAEMON_UPGRADE_ASSUME_READY === '1');
   const serviceBefore = await readServiceState(profile, env);
-  const previousPackageSpec = serviceBefore.packageSpec || `@magclaw/daemon@${previousVersion}`;
+  const previousPackageSpec = serviceBefore.packageSpec || packageSpecForPackageName(packageName, previousVersion);
   const dryRunPlan = {
     ok: true,
     dryRun: Boolean(flags.dryRun),
@@ -4657,6 +4896,9 @@ async function runUpgradeWorker(flags, env = process.env) {
     previousVersion,
     targetVersion,
     packageSpec,
+    packageName,
+    packageKind,
+    packageBin,
     previousPackageSpec,
     service: serviceBefore,
     localOnly,
@@ -4731,6 +4973,10 @@ async function runUpgradeWorker(flags, env = process.env) {
       mode: serviceBefore.mode || (process.platform === 'darwin' ? 'launchd' : process.platform === 'linux' ? 'systemd' : process.platform === 'win32' ? 'schtasks' : 'foreground'),
       background: true,
       packageSpec,
+      packageName,
+      packageVersion: targetVersion === 'latest' ? '' : targetVersion,
+      packageKind,
+      packageBin,
       previousPackageSpec,
       pendingCommandId: commandId,
       pendingTargetVersion: targetVersion,
@@ -4749,19 +4995,19 @@ async function runUpgradeWorker(flags, env = process.env) {
     const complete = progressSocket ? await progressSocket.waitForComplete(readyTimeoutMs) : null;
     if (complete?.status === 'succeeded') {
       await emitProgress({ status: 'succeeded', phase: 'ready', progress: 100, message: 'Daemon upgrade completed.' });
-      await writeServiceState(profile, { installedDaemonVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
+      await writeServiceState(profile, { installedDaemonVersion: targetVersion, installedPackageVersion: targetVersion, packageVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
       return { ok: true, commandId, targetVersion, packageSpec };
     }
     if (localOnly) {
       const ready = await waitForLocalDaemonReady(profile, readyTimeoutMs, env);
       if (!ready.ok) throw new Error(ready.error || 'Timed out waiting for the local daemon to become ready.');
       await emitProgress({ status: 'succeeded', phase: 'ready', progress: 100, message: 'Daemon upgrade completed locally.' });
-      await writeServiceState(profile, { installedDaemonVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
+      await writeServiceState(profile, { installedDaemonVersion: targetVersion, installedPackageVersion: targetVersion, packageVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
       return { ok: true, commandId, targetVersion, packageSpec, localReady: ready };
     }
     if (!progressSocket && assumeReady) {
       await emitProgress({ status: 'succeeded', phase: 'ready', progress: 100, message: 'Daemon upgrade completed locally.' });
-      await writeServiceState(profile, { installedDaemonVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
+      await writeServiceState(profile, { installedDaemonVersion: targetVersion, installedPackageVersion: targetVersion, packageVersion: targetVersion, pendingCommandId: '', pendingTargetVersion: '' }, env);
       return { ok: true, commandId, targetVersion, packageSpec, assumedReady: true };
     }
     throw new Error('Timed out waiting for upgraded daemon ready acknowledgement.');
@@ -4774,8 +5020,14 @@ async function runUpgradeWorker(flags, env = process.env) {
     await emitProgress({ status: 'rollback', phase: 'rollback', progress: 82, message: `Rolling back: ${upgradeError}`, error: upgradeError });
     let rollbackError = '';
     try {
+      const previousPackageInfo = packageInfoFromSpec(previousPackageSpec);
+      const rollbackPackageName = normalizeEntryPackageName(previousPackageInfo.name || serviceBefore.packageName || packageName);
       await writeServiceState(profile, {
         packageSpec: previousPackageSpec,
+        packageName: rollbackPackageName,
+        packageVersion: previousPackageInfo.version || serviceBefore.packageVersion || previousVersion,
+        packageKind: packageKindForPackageName(rollbackPackageName),
+        packageBin: serviceBefore.packageBin || packageBinForPackageName(rollbackPackageName),
         previousPackageSpec: packageSpec,
         pendingCommandId: '',
         pendingTargetVersion: '',
@@ -4838,6 +5090,7 @@ async function runComputerSetup(flags, env = process.env) {
   const profile = safeProfileName(flags.profile && flags.profile !== DEFAULT_PROFILE ? flags.profile : serverSlug);
   const owner = await ensureMachineFingerprint(profile, env);
   const displayName = String(flags.displayName || flags.name || os.hostname()).trim();
+  const packageInfo = runtimePackageInfo(env);
   const started = await postSetupJson(serverUrl, '/api/cloud/computer/setup/start', {
     serverSlug,
     machineFingerprint: owner.fingerprint,
@@ -4845,7 +5098,13 @@ async function runComputerSetup(flags, env = process.env) {
     hostname: os.hostname(),
     os: os.platform(),
     arch: os.arch(),
-    daemonVersion: DAEMON_VERSION,
+    daemonVersion: packageInfo.version || DAEMON_VERSION,
+    packageName: packageInfo.name,
+    packageVersion: packageInfo.version,
+    packageKind: packageInfo.kind,
+    packageSpec: packageInfo.spec,
+    packageBin: packageInfo.bin,
+    cliCoreVersion: CLI_CORE_VERSION,
   });
   process.stdout.write(`To finish login, open: ${started.verificationUri}\n`);
   process.stdout.write(`and enter the code:   ${started.userCode}\n`);
@@ -5012,7 +5271,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));