shennian 0.2.6 → 0.2.7

package/dist/src/upgrade/engine.d.ts

@@ -0,0 +1,64 @@
+export type UpgradeProgress = {
+    step: 'checking';
+} | {
+    step: 'backing-up';
+} | {
+    step: 'installing';
+    version: string;
+} | {
+    step: 'verifying';
+    version: string;
+} | {
+    step: 'restarting';
+    from: string;
+    to: string;
+} | {
+    step: 'done';
+    from: string;
+    to: string;
+};
+export type UpgradeResult = {
+    ok: true;
+    from: string;
+    to: string;
+} | {
+    ok: false;
+    error: string;
+    rolledBack?: boolean;
+};
+type UpgradeAttempt = {
+    from: string;
+    to: string;
+    attemptCount: number;
+    attemptAt: number;
+};
+export declare function getCurrentVersion(): string;
+export declare function fetchLatestVersion(): Promise<string>;
+/**
+ * Compare semver strings. Returns:
+ *   'none'  — same or older
+ *   'patch' — only patch differs
+ *   'minor' — minor or patch differs
+ *   'major' — major differs
+ */
+export declare function compareVersions(current: string, latest: string): 'none' | 'patch' | 'minor' | 'major';
+export declare function readUpgradeAttempt(): UpgradeAttempt | null;
+export declare function writeUpgradeAttempt(attempt: UpgradeAttempt): void;
+export declare function clearUpgradeAttempt(): void;
+/**
+ * Called on daemon startup. Detects crash loops from a failed upgrade and
+ * initiates rollback if crash count exceeds threshold.
+ * Returns true if rollback was performed (caller should exit and let service manager restart).
+ */
+export declare function handleStartupCrashCheck(): Promise<boolean>;
+export declare function performUpgrade(targetVersion: string, onProgress: (p: UpgradeProgress) => void): Promise<UpgradeResult>;
+export type VersionCheckResult = {
+    hasUpdate: false;
+} | {
+    hasUpdate: true;
+    current: string;
+    latest: string;
+    changeType: 'patch' | 'minor' | 'major';
+};
+export declare function checkForUpdate(): Promise<VersionCheckResult>;
+export {};

package/dist/src/upgrade/engine.js

@@ -0,0 +1,238 @@
+// @arch docs/architecture/cli/upgrade.md
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync, exec as execCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getShennianDir, resolveShennianPath } from '../config/index.js';
+const exec = promisify(execCb);
+const SHENNIAN_DIR = getShennianDir();
+const BACKUP_DIR = resolveShennianPath('backup');
+const UPGRADE_ATTEMPT_FILE = resolveShennianPath('upgrade-attempt.json');
+const MAX_CRASH_COUNT = 3;
+const BACKUP_TTL_DAYS = 7;
+// ─── Version helpers ─────────────────────────────────────────────────────────
+export function getCurrentVersion() {
+    try {
+        const pkgPath = findPackageJson();
+        if (pkgPath) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            return pkg.version;
+        }
+    }
+    catch { /* noop */ }
+    return '0.0.0';
+}
+function findPackageJson() {
+    // Walk up from this file's location to find package.json
+    let dir = path.dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 6; i++) {
+        const candidate = path.join(dir, 'package.json');
+        if (fs.existsSync(candidate)) {
+            const pkg = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+            if (pkg.name === 'shennian')
+                return candidate;
+        }
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+export async function fetchLatestVersion() {
+    const res = await fetch('https://registry.npmjs.org/shennian/latest', {
+        headers: { Accept: 'application/json' },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!res.ok)
+        throw new Error(`npm registry returned ${res.status}`);
+    const data = (await res.json());
+    return data.version;
+}
+/**
+ * Compare semver strings. Returns:
+ *   'none'  — same or older
+ *   'patch' — only patch differs
+ *   'minor' — minor or patch differs
+ *   'major' — major differs
+ */
+export function compareVersions(current, latest) {
+    const parse = (v) => v.replace(/^v/, '').split('.').map(Number);
+    const [cMaj, cMin, cPat] = parse(current);
+    const [lMaj, lMin, lPat] = parse(latest);
+    if (lMaj > cMaj)
+        return 'major';
+    if (lMaj === cMaj && lMin > cMin)
+        return 'minor';
+    if (lMaj === cMaj && lMin === cMin && lPat > cPat)
+        return 'patch';
+    return 'none';
+}
+// ─── npm global path helpers ──────────────────────────────────────────────────
+function getNpmGlobalRoot() {
+    return execSync('npm root -g', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+function getGlobalPkgDir() {
+    return path.join(getNpmGlobalRoot(), 'shennian');
+}
+function getGlobalBinScript() {
+    const root = getNpmGlobalRoot();
+    return path.join(root, 'shennian', 'dist', 'bin', 'shennian.js');
+}
+// ─── Backup / Restore ─────────────────────────────────────────────────────────
+function backupVersion(version) {
+    const pkgDir = getGlobalPkgDir();
+    const dest = path.join(BACKUP_DIR, version);
+    fs.mkdirSync(dest, { recursive: true });
+    fs.cpSync(pkgDir, dest, { recursive: true });
+}
+function restoreVersion(version) {
+    const src = path.join(BACKUP_DIR, version);
+    if (!fs.existsSync(src))
+        throw new Error(`Backup for ${version} not found`);
+    const pkgDir = getGlobalPkgDir();
+    fs.cpSync(src, pkgDir, { recursive: true, force: true });
+}
+function cleanOldBackups() {
+    try {
+        if (!fs.existsSync(BACKUP_DIR))
+            return;
+        const cutoff = Date.now() - BACKUP_TTL_DAYS * 86400_000;
+        for (const entry of fs.readdirSync(BACKUP_DIR)) {
+            const full = path.join(BACKUP_DIR, entry);
+            const stat = fs.statSync(full);
+            if (stat.mtimeMs < cutoff) {
+                fs.rmSync(full, { recursive: true, force: true });
+            }
+        }
+    }
+    catch { /* noop */ }
+}
+// ─── Upgrade attempt tracking (crash detection) ───────────────────────────────
+export function readUpgradeAttempt() {
+    try {
+        return JSON.parse(fs.readFileSync(UPGRADE_ATTEMPT_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeUpgradeAttempt(attempt) {
+    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.writeFileSync(UPGRADE_ATTEMPT_FILE, JSON.stringify(attempt, null, 2));
+}
+export function clearUpgradeAttempt() {
+    try {
+        fs.unlinkSync(UPGRADE_ATTEMPT_FILE);
+    }
+    catch { /* noop */ }
+}
+/**
+ * Called on daemon startup. Detects crash loops from a failed upgrade and
+ * initiates rollback if crash count exceeds threshold.
+ * Returns true if rollback was performed (caller should exit and let service manager restart).
+ */
+export async function handleStartupCrashCheck() {
+    const attempt = readUpgradeAttempt();
+    if (!attempt)
+        return false;
+    const elapsed = Date.now() - attempt.attemptAt;
+    // If more than 10 minutes have passed, this is a stale record — clear and continue
+    if (elapsed > 10 * 60 * 1000) {
+        clearUpgradeAttempt();
+        return false;
+    }
+    attempt.attemptCount++;
+    if (attempt.attemptCount >= MAX_CRASH_COUNT) {
+        console.error(`[upgrade] New version crashed ${attempt.attemptCount} times, rolling back to ${attempt.from}...`);
+        try {
+            restoreVersion(attempt.from);
+            clearUpgradeAttempt();
+            console.error(`[upgrade] Rolled back to ${attempt.from}. Restarting...`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[upgrade] Rollback failed: ${err instanceof Error ? err.message : String(err)}`);
+            clearUpgradeAttempt();
+            return false;
+        }
+    }
+    writeUpgradeAttempt(attempt);
+    return false;
+}
+// ─── Core upgrade ─────────────────────────────────────────────────────────────
+export async function performUpgrade(targetVersion, onProgress) {
+    const currentVersion = getCurrentVersion();
+    if (currentVersion === targetVersion) {
+        return { ok: false, error: `Already on version ${targetVersion}` };
+    }
+    // Step 1: Verify npm is accessible
+    onProgress({ step: 'checking' });
+    try {
+        execSync('npm --version', { stdio: 'pipe' });
+    }
+    catch {
+        return { ok: false, error: 'npm is not available in PATH' };
+    }
+    // Step 2: Backup current version
+    onProgress({ step: 'backing-up' });
+    try {
+        fs.mkdirSync(BACKUP_DIR, { recursive: true });
+        backupVersion(currentVersion);
+    }
+    catch (err) {
+        return { ok: false, error: `Backup failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    // Step 3: npm install new version
+    onProgress({ step: 'installing', version: targetVersion });
+    try {
+        await exec(`npm install -g shennian@${targetVersion}`, { timeout: 120_000 });
+    }
+    catch (err) {
+        // Restore backup and abort
+        try {
+            restoreVersion(currentVersion);
+        }
+        catch { /* best effort */ }
+        return {
+            ok: false,
+            error: `npm install failed: ${err instanceof Error ? err.message : String(err)}`,
+            rolledBack: true,
+        };
+    }
+    // Step 4: Smoke test — verify the new binary works
+    onProgress({ step: 'verifying', version: targetVersion });
+    try {
+        const binScript = getGlobalBinScript();
+        const { stdout } = await exec(`node "${binScript}" --version`, { timeout: 10_000 });
+        if (!stdout.trim())
+            throw new Error('Empty output from --version check');
+    }
+    catch (err) {
+        try {
+            restoreVersion(currentVersion);
+        }
+        catch { /* best effort */ }
+        return {
+            ok: false,
+            error: `Smoke test failed: ${err instanceof Error ? err.message : String(err)}`,
+            rolledBack: true,
+        };
+    }
+    // Step 5: Write upgrade attempt file (crash detection on restart)
+    writeUpgradeAttempt({
+        from: currentVersion,
+        to: targetVersion,
+        attemptCount: 0,
+        attemptAt: Date.now(),
+    });
+    cleanOldBackups();
+    // Step 6: Signal restart (caller sends upgrade.status: restarting before killing)
+    onProgress({ step: 'restarting', from: currentVersion, to: targetVersion });
+    return { ok: true, from: currentVersion, to: targetVersion };
+}
+export async function checkForUpdate() {
+    const current = getCurrentVersion();
+    const latest = await fetchLatestVersion();
+    const changeType = compareVersions(current, latest);
+    if (changeType === 'none')
+        return { hasUpdate: false };
+    return { hasUpdate: true, current, latest, changeType };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "Shennian — AI Agent Mobile Console CLI",
   "type": "module",
   "bin": {
@@ -50,7 +50,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "build:publish": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.publish.json",
+    "build:publish": "node -e \"const fs=require('node:fs'); fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('.tsbuildinfo.publish', { force: true })\" && tsc -p tsconfig.publish.json",
     "dev": "tsc --watch"
   }
 }