@magclaw/cli-core 0.1.29 → 0.1.31

package/package.json

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

package/src/cli.js

@@ -588,7 +588,7 @@ function renderHelp() {
     '  status       Show daemon status for one profile',
     '  list         List local daemon profiles and connected Computers',
     '  logs         Print recent daemon logs for one profile',
-    '  install-cli  Install or repair the durable magclaw command shim',
+    '  install-cli  Install or repair durable magclaw command shims',
     '  upgrade      Upgrade the background daemon package',
     '  doctor       Show runtime and environment diagnostics',
     '  uninstall    Stop and remove the background daemon service',
@@ -1110,64 +1110,88 @@ function defaultCliPackageSpec(env = process.env) {
   return String(env.MAGCLAW_CLI_PACKAGE_SPEC || '@magclaw/cli-core@latest').trim() || '@magclaw/cli-core@latest';
 }
 
+function defaultComputerCliPackageSpec(env = process.env) {
+  return String(env.MAGCLAW_COMPUTER_CLI_PACKAGE_SPEC || '@magclaw/computer@latest').trim() || '@magclaw/computer@latest';
+}
+
 function defaultCliNpmPath(env = process.env) {
   return commandExists('npm', env) || (process.platform === 'win32' ? 'npm.cmd' : 'npm');
 }
 
-export function renderCliShimFiles({ platform = process.platform, npmPath = '', packageSpec = '@magclaw/cli-core@latest' } = {}) {
+function cliShimTargets({ packageSpec = '@magclaw/cli-core@latest', computerPackageSpec = '@magclaw/computer@latest' } = {}) {
+  return [
+    {
+      command: 'magclaw',
+      packageSpec: String(packageSpec || '@magclaw/cli-core@latest').trim() || '@magclaw/cli-core@latest',
+    },
+    {
+      command: 'magclaw-computer',
+      packageSpec: String(computerPackageSpec || '@magclaw/computer@latest').trim() || '@magclaw/computer@latest',
+    },
+  ];
+}
+
+export function renderCliShimFiles({
+  platform = process.platform,
+  npmPath = '',
+  packageSpec = '@magclaw/cli-core@latest',
+  computerPackageSpec = '@magclaw/computer@latest',
+} = {}) {
   const targetPackage = String(packageSpec || '@magclaw/cli-core@latest').trim() || '@magclaw/cli-core@latest';
+  const targetComputerPackage = String(computerPackageSpec || '@magclaw/computer@latest').trim() || '@magclaw/computer@latest';
   const targetNpm = String(npmPath || (platform === 'win32' ? 'npm.cmd' : 'npm')).trim() || (platform === 'win32' ? 'npm.cmd' : 'npm');
+  const targets = cliShimTargets({ packageSpec: targetPackage, computerPackageSpec: targetComputerPackage });
   if (platform === 'win32') {
     const fallback = path.win32.basename(targetNpm) || 'npm.cmd';
-    return [
+    return targets.flatMap((target) => [
       {
-        name: 'magclaw.cmd',
+        name: `${target.command}.cmd`,
         executable: true,
         content: [
           '@echo off',
           'setlocal',
           `set "NPM_BIN=${cmdEnvValue(targetNpm)}"`,
           `if not exist "%NPM_BIN%" set "NPM_BIN=${cmdEnvValue(fallback)}"`,
-          `set "PACKAGE_SPEC=${cmdEnvValue(targetPackage)}"`,
+          `set "PACKAGE_SPEC=${cmdEnvValue(target.packageSpec)}"`,
           'set "ARGS=%*"',
-          '"%NPM_BIN%" exec --yes --package "%PACKAGE_SPEC%" -- magclaw %ARGS%',
+          `"%NPM_BIN%" exec --yes --package "%PACKAGE_SPEC%" -- ${target.command} %ARGS%`,
           'exit /b %ERRORLEVEL%',
           '',
         ].join('\r\n'),
       },
       {
-        name: 'magclaw.ps1',
+        name: `${target.command}.ps1`,
         executable: true,
         content: [
           `$npmBin = ${psSingleQuote(targetNpm)}`,
           `if (-not (Test-Path -LiteralPath $npmBin)) { $npmBin = ${psSingleQuote(fallback)} }`,
-          `$packageSpec = ${psSingleQuote(targetPackage)}`,
-          '& $npmBin exec --yes --package $packageSpec -- magclaw @args',
+          `$packageSpec = ${psSingleQuote(target.packageSpec)}`,
+          `& $npmBin exec --yes --package $packageSpec -- ${target.command} @args`,
           'exit $LASTEXITCODE',
           '',
         ].join('\n'),
       },
-    ];
+    ]);
   }
   const fallback = path.basename(targetNpm) || 'npm';
-  return [
+  return targets.map((target) => (
     {
-      name: 'magclaw',
+      name: target.command,
       executable: true,
       content: [
         '#!/bin/sh',
         'set -eu',
         '# MagClaw CLI shim generated by @magclaw/cli-core.',
         `NPM_BIN=${shSingleQuote(targetNpm)}`,
-        `PACKAGE_SPEC=${shSingleQuote(targetPackage)}`,
+        `PACKAGE_SPEC=${shSingleQuote(target.packageSpec)}`,
         'if [ ! -x "$NPM_BIN" ]; then',
         `  NPM_BIN=${shSingleQuote(fallback)}`,
         'fi',
-        'exec "$NPM_BIN" exec --yes --package "$PACKAGE_SPEC" -- magclaw "$@"',
+        `exec "$NPM_BIN" exec --yes --package "$PACKAGE_SPEC" -- ${target.command} "$@"`,
         '',
       ].join('\n'),
-    },
-  ];
+    }
+  ));
 }
 
 async function chooseCliShimBinDir(options = {}, env = process.env) {
@@ -1203,17 +1227,21 @@ async function chooseCliShimBinDir(options = {}, env = process.env) {
   return { dir: fallback, explicit: false, pathReady: directoryIsInPath(fallback, env) };
 }
 
-async function existingDurableMagclawCommand(env = process.env) {
-  const existing = commandExists('magclaw', env);
+function isGeneratedMagClawShim(content = '') {
+  return Boolean(
+    content.includes('MagClaw CLI shim generated by @magclaw/cli-core')
+    || content.includes('MagClaw CLI shim generated by @magclaw/daemon')
+    || content.includes('@magclaw/cli-core@')
+    || content.includes('@magclaw/daemon@')
+    || content.includes('@magclaw/computer@')
+  );
+}
+
+async function existingDurableMagclawCommand(command = 'magclaw', env = process.env) {
+  const existing = commandExists(command, env);
   if (!existing || pathLooksEphemeralCli(existing)) return '';
   const content = await readFile(existing, 'utf8').catch(() => '');
-  if (
-    content
-    && !content.includes('MagClaw CLI shim generated by @magclaw/cli-core')
-    && !content.includes('MagClaw CLI shim generated by @magclaw/daemon')
-    && !content.includes('@magclaw/cli-core@')
-    && !content.includes('@magclaw/daemon@')
-  ) {
+  if (content && !isGeneratedMagClawShim(content)) {
     return '';
   }
   return existing;
@@ -1222,12 +1250,7 @@ async function existingDurableMagclawCommand(env = process.env) {
 async function writeCliShimFile(file, content, { force = false } = {}) {
   if (existsSync(file) && !force) {
     const existing = await readFile(file, 'utf8').catch(() => '');
-    if (
-      !existing.includes('MagClaw CLI shim generated by @magclaw/cli-core')
-      && !existing.includes('MagClaw CLI shim generated by @magclaw/daemon')
-      && !existing.includes('@magclaw/cli-core@')
-      && !existing.includes('@magclaw/daemon@')
-    ) {
+    if (!isGeneratedMagClawShim(existing)) {
       const error = new Error(`Refusing to overwrite existing non-MagClaw command: ${file}`);
       error.code = 'EEXIST';
       throw error;
@@ -1241,16 +1264,39 @@ async function installCliShim(options = {}, env = process.env) {
   if (env.MAGCLAW_INSTALL_CLI === '0' || options.installCli === false || options.noInstallCli) {
     return { ok: true, command: 'magclaw', installed: false, skipped: true, reason: 'disabled' };
   }
-  const existing = await existingDurableMagclawCommand(env);
-  if (existing && !options.binDir && !options.cliBinDir && !options.force) {
-    return { ok: true, command: 'magclaw', installed: false, path: existing, files: [existing], pathReady: true, reason: 'already_available' };
+  const existing = await existingDurableMagclawCommand('magclaw', env);
+  const existingComputer = await existingDurableMagclawCommand('magclaw-computer', env);
+  const existingCommandsShareDir = Boolean(
+    existing
+    && existingComputer
+    && path.dirname(existing) === path.dirname(existingComputer)
+  );
+  if (existingCommandsShareDir && !options.binDir && !options.cliBinDir && !options.force) {
+    return {
+      ok: true,
+      command: 'magclaw',
+      commands: ['magclaw', 'magclaw-computer'],
+      installed: false,
+      path: existing,
+      files: [existing, existingComputer],
+      pathReady: true,
+      reason: 'already_available',
+    };
   }
 
-  const target = await chooseCliShimBinDir(options, env);
+  const target = (existing || existingComputer) && !options.binDir && !options.cliBinDir && !options.force
+    ? { dir: path.dirname(existing || existingComputer), explicit: false, pathReady: true }
+    : await chooseCliShimBinDir(options, env);
   await mkdir(target.dir, { recursive: true });
   const npmPath = String(options.npmPath || defaultCliNpmPath(env)).trim() || (process.platform === 'win32' ? 'npm.cmd' : 'npm');
   const packageSpec = String(options.packageSpec || options.cliPackageSpec || defaultCliPackageSpec(env)).trim() || '@magclaw/cli-core@latest';
-  const shimFiles = renderCliShimFiles({ platform: process.platform, npmPath, packageSpec });
+  const computerPackageSpec = String(options.computerPackageSpec || options.computerCliPackageSpec || defaultComputerCliPackageSpec(env)).trim() || '@magclaw/computer@latest';
+  const shimFiles = renderCliShimFiles({
+    platform: process.platform,
+    npmPath,
+    packageSpec,
+    computerPackageSpec,
+  });
   const written = [];
   for (const shim of shimFiles) {
     const file = path.join(target.dir, shim.name);
@@ -1260,12 +1306,14 @@ async function installCliShim(options = {}, env = process.env) {
   return {
     ok: true,
     command: 'magclaw',
+    commands: ['magclaw', 'magclaw-computer'],
     installed: true,
     binDir: target.dir,
     files: written,
     path: written[0] || '',
     pathReady: Boolean(target.pathReady),
     packageSpec,
+    computerPackageSpec,
     npmPath,
   };
 }
@@ -5567,8 +5615,12 @@ function normalizeSetupServerSlug(value = '') {
   return String(value || '').trim().replace(/^\/+/, '').replace(/\/+$/, '');
 }
 
+function normalizeSetupServerUrl(value = '') {
+  return String(value || DEFAULT_SERVER_URL).replace(/\/+$/, '');
+}
+
 async function postSetupJson(serverUrl, pathname, body = {}) {
-  const url = `${String(serverUrl || DEFAULT_SERVER_URL).replace(/\/+$/, '')}${pathname}`;
+  const url = `${normalizeSetupServerUrl(serverUrl)}${pathname}`;
   const response = await fetch(url, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
@@ -5593,6 +5645,113 @@ function computerTargetProfile(flags = {}, fallback = DEFAULT_PROFILE) {
   return profileFromComputerTarget(flags.server || flags.serverSlug || flags.slug || flags._?.[1] || flags.profile || fallback);
 }
 
+function savedComputerSetupMatches(config = {}, target = {}) {
+  const token = String(config.token || config.machineToken || config.apiKey || '').trim();
+  const computerId = String(config.computerId || '').trim();
+  if (!token || !computerId) return false;
+  if (normalizeSetupServerUrl(config.serverUrl) !== normalizeSetupServerUrl(target.serverUrl)) return false;
+
+  const targetProfile = safeProfileName(target.profile || target.serverSlug || DEFAULT_PROFILE);
+  const configProfile = safeProfileName(config.profile || targetProfile);
+  if (configProfile !== targetProfile) return false;
+
+  const targetSlug = normalizeSetupServerSlug(target.serverSlug);
+  const configSlug = normalizeSetupServerSlug(config.serverSlug || config.slug || '');
+  if (configSlug && targetSlug && configSlug !== targetSlug) return false;
+  return true;
+}
+
+async function reusableComputerSetupProfile(target = {}, env = process.env) {
+  if (target.force || target.relogin || target.reauthorize) return null;
+  const profile = safeProfileName(target.profile || target.serverSlug || DEFAULT_PROFILE);
+  const config = await readProfile(profile, env);
+  if (!savedComputerSetupMatches(config, { ...target, profile })) return null;
+  const service = await readServiceState(profile, env);
+  if (service.remoteClosed) return null;
+  return {
+    config: {
+      ...config,
+      profile,
+      serverUrl: normalizeSetupServerUrl(config.serverUrl || target.serverUrl),
+      token: String(config.token || config.machineToken || config.apiKey || '').trim(),
+      pairToken: '',
+    },
+    service,
+    serviceStatus: backgroundServiceStatus(profile, env),
+  };
+}
+
+async function finishReusableComputerSetup(existing, flags = {}, env = process.env) {
+  const requestedSlug = normalizeSetupServerSlug(flags._?.[1] || flags.server || flags.serverSlug || flags.slug);
+  const serverSlug = existing.config.serverSlug || requestedSlug;
+  const config = await buildConfig({
+    ...flags,
+    profile: existing.config.profile,
+    serverUrl: existing.config.serverUrl,
+    apiKey: existing.config.token,
+    computerId: existing.config.computerId,
+    workspaceId: existing.config.workspaceId || existing.config.workspace,
+    name: existing.config.name,
+    serverName: existing.config.serverName || serverSlug,
+    serverSlug,
+    fingerprint: existing.config.fingerprint,
+  }, env);
+  await saveProfile(config.profile, config, env);
+  const cli = await tryInstallCliShim(flags, env);
+  const computerName = config.computerName || config.name || os.hostname();
+  const basePayload = {
+    cli,
+    computerId: config.computerId,
+    computerName,
+    profile: config.profile,
+    serverName: config.serverName,
+    serverSlug: config.serverSlug,
+    reused: true,
+    reason: 'already_configured',
+  };
+  if (flags.noStart || flags.noRun) {
+    printJson({
+      ok: true,
+      started: false,
+      ...basePayload,
+      next: `Run magclaw-computer start ${config.profile} when ready.`,
+    });
+    return;
+  }
+
+  const serviceStatus = existing.serviceStatus || backgroundServiceStatus(config.profile, env);
+  let result;
+  if (serviceStatus.active) {
+    result = {
+      ok: true,
+      mode: serviceStatus.mode,
+      active: true,
+      alreadyRunning: true,
+      started: false,
+      label: serviceStatus.label,
+      serviceName: serviceStatus.serviceName,
+      taskName: serviceStatus.taskName,
+      file: serviceStatus.file,
+      status: serviceStatus.status,
+      state: serviceStatus.state,
+    };
+  } else {
+    const started = await startBackground(config.profile, env);
+    result = {
+      ...started,
+      started: Boolean(started.ok),
+    };
+  }
+  printJson({
+    ...result,
+    ...basePayload,
+  });
+  if (!result.ok) {
+    logWarning('daemon', 'Falling back to foreground mode.');
+    await runForegroundDaemon(config, env);
+  }
+}
+
 async function runComputerSetup(flags, env = process.env) {
   const subcommand = String(flags._?.[0] || '').trim();
   if (!['setup', 'attach', 'login'].includes(subcommand)) {
@@ -5600,8 +5759,18 @@ async function runComputerSetup(flags, env = process.env) {
   }
   const serverSlug = normalizeSetupServerSlug(flags._?.[1] || flags.server || flags.serverSlug || flags.slug);
   if (!serverSlug) throw new Error('Run computer setup with a server slug, for example: magclaw computer setup /my-server');
-  const serverUrl = String(flags.serverUrl || env.MAGCLAW_PUBLIC_URL || DEFAULT_SERVER_URL).replace(/\/+$/, '');
+  const serverUrl = normalizeSetupServerUrl(flags.serverUrl || env.MAGCLAW_PUBLIC_URL || DEFAULT_SERVER_URL);
   const profile = safeProfileName(flags.profile && flags.profile !== DEFAULT_PROFILE ? flags.profile : serverSlug);
+  const existing = await reusableComputerSetupProfile({
+    ...flags,
+    profile,
+    serverSlug,
+    serverUrl,
+  }, env);
+  if (existing) {
+    await finishReusableComputerSetup(existing, flags, env);
+    return;
+  }
   const owner = await ensureMachineFingerprint(profile, env);
   const displayName = String(flags.displayName || flags.name || os.hostname()).trim();
   const packageInfo = runtimePackageInfo(env);