agent-tempo 1.0.1

package/dist/cli/upgrade-command.js

@@ -0,0 +1,240 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgrade = upgrade;
+/**
+ * `agent-tempo upgrade` CLI handler.
+ *
+ * **Critical constraint**: this module must NOT statically import from
+ * `@temporalio/*`, `../workflows/*`, `../adapters/*`, `../spawn`, `../client`,
+ * `./commands`, `./preflight`, or any module that transitively pulls in the
+ * Temporal SDK. The `upgrade` command must remain operable when the Temporal
+ * SDK itself is broken — that's the entire point of upgrading (users invoke
+ * `upgrade` precisely when the installed SDK is failing).
+ *
+ * Temporal connection is used ONLY for the optional "warn about active
+ * sessions" informational step. It's dynamic-imported inside the existing
+ * try/catch — if the SDK fails to load, the warning is silently skipped
+ * (strictly better than a crash). The user is already getting fresh binaries
+ * via `npm install -g agent-tempo`.
+ *
+ * Extracted from `src/cli/commands.ts` in issue #157 PR C.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const daemon_1 = require("./daemon");
+const out = __importStar(require("./output"));
+/** Package root is two levels up from dist/cli/ */
+const PACKAGE_ROOT = (0, path_1.resolve)(__dirname, '..', '..');
+async function upgrade(opts) {
+    const config = (0, config_1.getConfig)(opts);
+    const targetVersion = opts.version || 'latest';
+    const installSpec = targetVersion === 'latest' ? 'agent-tempo' : `agent-tempo@${targetVersion}`;
+    // Read current version
+    let currentVersion = 'unknown';
+    try {
+        const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(PACKAGE_ROOT, 'package.json'), 'utf8'));
+        currentVersion = pkg.version || 'unknown';
+    }
+    catch { /* ignore */ }
+    out.heading('agent-tempo upgrade');
+    out.log(`  Current: v${currentVersion}`);
+    out.log(`  Target:  ${targetVersion}`);
+    console.log();
+    // Check for active sessions — warn the user.
+    //
+    // #157 PR C: Temporal bits are dynamic-imported so the whole check path
+    // crash-proofs under a broken SDK install. Previously a top-level
+    // `@temporalio/client` import crashed `upgrade` before the npm install
+    // ever ran — exactly the scenario the user was trying to recover from.
+    // Now: broken SDK → silently skip warning, continue with upgrade. The
+    // warning is a courtesy, not a safety gate.
+    let activeSessions = 0;
+    try {
+        const { Client } = await Promise.resolve().then(() => __importStar(require('@temporalio/client')));
+        const { createTemporalConnection } = await Promise.resolve().then(() => __importStar(require('../connection')));
+        const connection = await Promise.race([
+            createTemporalConnection(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+        const client = new Client({ connection, namespace: config.temporalNamespace });
+        const query = 'WorkflowType = "agentSessionWorkflow" AND ExecutionStatus = "Running"';
+        for await (const _wf of client.workflow.list({ query })) {
+            activeSessions++;
+        }
+    }
+    catch {
+        // Either Temporal SDK failed to load (broken install — the scenario we're
+        // trying to upgrade out of), or connection failed (server down). Either
+        // way: skip the warning, proceed with upgrade.
+    }
+    if (activeSessions > 0) {
+        out.warn(`${activeSessions} active session(s) detected. They will lose daemon connectivity during upgrade.`);
+        out.log(`  ${out.dim('Consider running: agent-tempo stop --all')}`);
+        console.log();
+    }
+    // Stop the daemon gracefully (releases .node file locks)
+    const daemonWasRunning = (0, daemon_1.isDaemonRunning)();
+    if (daemonWasRunning) {
+        out.log('Stopping daemon...');
+        (0, daemon_1.stopDaemon)();
+        // Wait for process to exit — important on Windows for file lock release
+        const deadline = Date.now() + 5000;
+        while (Date.now() < deadline && (0, daemon_1.isDaemonRunning)()) {
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        if ((0, daemon_1.isDaemonRunning)()) {
+            out.error('Daemon did not stop in time. Try: agent-tempo daemon stop');
+            process.exit(1);
+        }
+        out.success('Daemon stopped');
+    }
+    // Build the detached updater script.
+    // This is a self-contained Node.js script (no native module deps) that:
+    //   1. Waits for the CLI process to exit (by PID)
+    //   2. Runs npm install -g
+    //   3. Verifies the install
+    //   4. Restarts the daemon
+    const cliPid = process.pid;
+    const isWin = process.platform === 'win32';
+    const updaterScript = `
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+
+const PID = ${cliPid};
+const INSTALL_SPEC = ${JSON.stringify(installSpec)};
+const TARGET = ${JSON.stringify(targetVersion)};
+const IS_WIN = ${isWin};
+const LOG_PATH = ${JSON.stringify((0, path_1.join)(config_1.AGENT_TEMPO_HOME, 'upgrade.log'))};
+
+function log(msg) {
+  const line = new Date().toISOString() + ' ' + msg;
+  try { fs.appendFileSync(LOG_PATH, line + '\\n'); } catch {}
+  console.log(msg);
+}
+
+function isPidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch { return false; }
+}
+
+async function main() {
+  // Wait for CLI process to exit (up to 10s)
+  log('Waiting for CLI process (pid ' + PID + ') to exit...');
+  const deadline = Date.now() + 10000;
+  while (Date.now() < deadline && isPidAlive(PID)) {
+    await new Promise(r => setTimeout(r, 300));
+  }
+  if (isPidAlive(PID)) {
+    log('WARNING: CLI process still alive after 10s, proceeding anyway');
+  }
+
+  // Run npm install -g
+  log('Installing ' + INSTALL_SPEC + '...');
+  try {
+    const npmCmd = IS_WIN ? 'npm.cmd' : 'npm';
+    execFileSync(npmCmd, ['install', '-g', INSTALL_SPEC], {
+      stdio: 'inherit',
+      timeout: 120000,
+    });
+    log('Install completed');
+  } catch (err) {
+    log('Install FAILED: ' + err.message);
+    log('Recovery: npm install -g ' + INSTALL_SPEC);
+    process.exit(1);
+  }
+
+  // Verify installation
+  try {
+    const tempoCmd = IS_WIN ? 'agent-tempo.cmd' : 'agent-tempo';
+    const ver = execFileSync(tempoCmd, ['--version'], {
+      encoding: 'utf8',
+      timeout: 10000,
+    }).trim();
+    log('Verified: ' + ver);
+  } catch (err) {
+    log('WARNING: Could not verify installation: ' + err.message);
+    log('Recovery: npm install -g agent-tempo');
+  }
+
+  // Restart the daemon
+  log('Restarting daemon...');
+  try {
+    const tempoCmd = IS_WIN ? 'agent-tempo.cmd' : 'agent-tempo';
+    execFileSync(tempoCmd, ['daemon', 'start'], {
+      stdio: 'inherit',
+      timeout: 30000,
+    });
+    log('Daemon restarted');
+  } catch (err) {
+    log('WARNING: Daemon restart failed: ' + err.message);
+    log('Run manually: agent-tempo daemon start');
+  }
+
+  log('Upgrade complete!');
+}
+
+main().catch(err => {
+  log('Upgrade failed: ' + err.message);
+  process.exit(1);
+});
+`.trim();
+    // Clear previous upgrade log before spawning
+    const logPath = (0, path_1.join)(config_1.AGENT_TEMPO_HOME, 'upgrade.log');
+    try {
+        (0, fs_1.writeFileSync)(logPath, '');
+    }
+    catch { /* ignore */ }
+    // Spawn the updater as a detached child process
+    out.log(`Spawning upgrade process for ${out.cyan(installSpec)}...`);
+    const child = (0, child_process_1.spawn)(process.execPath, ['-e', updaterScript], {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+    });
+    child.unref();
+    console.log();
+    out.success('Upgrade started in background');
+    out.log(`  ${out.dim('Monitor progress: ')}`);
+    if (isWin) {
+        out.log(`    ${out.dim('powershell Get-Content -Wait "' + logPath + '"')}`);
+    }
+    else {
+        out.log(`    ${out.dim('tail -f ' + logPath)}`);
+    }
+    out.log(`  ${out.dim('If it fails, run manually: npm install -g ' + installSpec)}`);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './cli/dev-mode-bootstrap';