shennian 0.2.16 → 0.2.18

package/dist/src/commands/upgrade.js

@@ -3,7 +3,7 @@
 import chalk from 'chalk';
 import { execSync, spawn } from 'node:child_process';
 import os from 'node:os';
-import { getCurrentVersion, fetchLatestVersion, compareVersions, performUpgrade, checkForUpdate, } from '../upgrade/engine.js';
+import { getCurrentVersion, fetchLatestVersion, compareVersions, performUpgrade, checkForUpdate, recordUpgradeFailure, } from '../upgrade/engine.js';
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 export function restartCurrentDaemonAfterUpgrade(deps = {}) {
     const platform = deps.platform ?? os.platform();
@@ -120,6 +120,7 @@ export function registerUpgradeCommand(program) {
             restartCurrentDaemonAfterUpgrade();
         }
         else {
+            recordUpgradeFailure(latest, result.error);
             console.log();
             if (result.rolledBack) {
                 console.error(chalk.red(`✗ Upgrade failed (rolled back to ${current})`));
@@ -174,6 +175,8 @@ export async function handleUpgradeStart(client, reqId, targetVersion) {
         restartCurrentDaemonAfterUpgrade();
     }
     else {
+        const failure = recordUpgradeFailure(latest, result.error);
+        console.log(`[${new Date().toISOString()}] [upgrade] ${latest} failed, retry after ${new Date(failure.nextRetryAt).toISOString()}: ${result.error}`);
         sendEvent({
             state: result.rolledBack ? 'rolledback' : 'failed',
             machineId: 'self',

package/dist/src/index.js

@@ -13,7 +13,7 @@ import { registerAgentCommand } from './commands/agent.js';
 import { registerUpgradeCommand } from './commands/upgrade.js';
 import { SessionManager } from './session/manager.js';
 import { SERVERS, regionToUrl, urlToRegion } from './region.js';
-import { getCurrentVersion, handleStartupCrashCheck, checkForUpdate } from './upgrade/engine.js';
+import { getCurrentVersion, handleStartupCrashCheck, checkForUpdate, isUpgradeVersionInCooldown, recordUpgradeFailure, } from './upgrade/engine.js';
 import { detectAgents } from './agents/detect.js';
 const cliVersion = getCurrentVersion();
 import { getCachedAgentInfos, resolveAgentInfos } from './agents/model-registry.js';
@@ -281,25 +281,45 @@ program.parse();
 async function scheduleAutoUpgrade(client, policy) {
     if (policy === 'none')
         return;
-    // Delay slightly so we don't hit npm on every cold start during development
-    await new Promise((r) => setTimeout(r, 30_000));
-    let result;
-    try {
-        result = await checkForUpdate();
-    }
-    catch {
-        return; // silently skip on network error
-    }
-    if (!result.hasUpdate)
-        return;
-    const { changeType, current, latest } = result;
-    // Respect the policy
-    if (policy === 'patch' && changeType !== 'patch')
-        return;
-    if (policy === 'minor' && changeType === 'major')
-        return;
-    console.log(`[${new Date().toISOString()}] [upgrade] ${current} → ${latest} (${changeType}), auto-upgrading...`);
-    const { handleUpgradeStart } = await import('./commands/upgrade.js');
-    // Use a dummy reqId since this is self-triggered
-    await handleUpgradeStart(client, 'auto-upgrade', latest);
+    let upgradeInFlight = false;
+    const tick = async () => {
+        if (upgradeInFlight)
+            return;
+        let result;
+        try {
+            result = await checkForUpdate();
+        }
+        catch {
+            return; // silently skip on network error
+        }
+        if (!result.hasUpdate)
+            return;
+        const { changeType, current, latest } = result;
+        // Respect the policy
+        if (policy === 'patch' && changeType !== 'patch')
+            return;
+        if (policy === 'minor' && changeType === 'major')
+            return;
+        if (isUpgradeVersionInCooldown(latest))
+            return;
+        console.log(`[${new Date().toISOString()}] [upgrade] ${current} → ${latest} (${changeType}), auto-upgrading...`);
+        upgradeInFlight = true;
+        try {
+            const { handleUpgradeStart } = await import('./commands/upgrade.js');
+            // Use a dummy reqId since this is self-triggered
+            await handleUpgradeStart(client, 'auto-upgrade', latest);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const failure = recordUpgradeFailure(latest, message);
+            console.log(`[${new Date().toISOString()}] [upgrade] ${latest} failed, retry after ${new Date(failure.nextRetryAt).toISOString()}: ${message}`);
+        }
+        finally {
+            upgradeInFlight = false;
+        }
+    };
+    // Delay slightly so we don't hit npm on every cold start during development,
+    // then keep polling so a bad published patch can be superseded by a good one.
+    setTimeout(() => void tick(), 30_000);
+    setInterval(() => void tick(), 30 * 60_000);
 }

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

@@ -32,6 +32,17 @@ type UpgradeAttempt = {
     attemptCount: number;
     attemptAt: number;
 };
+export type UpgradeFailureRecord = {
+    version: string;
+    failureCount: number;
+    firstFailedAt: number;
+    lastFailedAt: number;
+    nextRetryAt: number;
+    error: string;
+};
+export type UpgradeFailures = {
+    versions: Record<string, UpgradeFailureRecord>;
+};
 export declare function getCurrentVersion(): string;
 export declare function findPackageJson(startFilePath?: string): string | null;
 export declare function fetchLatestVersion(): Promise<string>;
@@ -46,6 +57,11 @@ export declare function compareVersions(current: string, latest: string): 'none'
 export declare function readUpgradeAttempt(): UpgradeAttempt | null;
 export declare function writeUpgradeAttempt(attempt: UpgradeAttempt): void;
 export declare function clearUpgradeAttempt(): void;
+export declare function readUpgradeFailures(filePath?: string): UpgradeFailures;
+export declare function getUpgradeRetryDelayMs(failureCount: number): number;
+export declare function isUpgradeVersionInCooldown(version: string, now?: number, failures?: UpgradeFailures): boolean;
+export declare function recordUpgradeFailure(version: string, error: string, now?: number): UpgradeFailureRecord;
+export declare function clearUpgradeFailure(version: string): void;
 /**
  * Called on daemon startup. Detects crash loops from a failed upgrade and
  * initiates rollback if crash count exceeds threshold.

package/dist/src/upgrade/engine.js

@@ -6,11 +6,16 @@ import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 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;
+const RETRY_DELAYS_MS = [
+    5 * 60_000,
+    30 * 60_000,
+    2 * 60 * 60_000,
+    6 * 60 * 60_000,
+];
 // ─── Version helpers ─────────────────────────────────────────────────────────
 export function getCurrentVersion() {
     try {
@@ -116,7 +121,7 @@ export function readUpgradeAttempt() {
     }
 }
 export function writeUpgradeAttempt(attempt) {
-    fs.mkdirSync(SHENNIAN_DIR, { recursive: true });
+    fs.mkdirSync(getShennianDir(), { recursive: true });
     fs.writeFileSync(UPGRADE_ATTEMPT_FILE, JSON.stringify(attempt, null, 2));
 }
 export function clearUpgradeAttempt() {
@@ -125,6 +130,54 @@ export function clearUpgradeAttempt() {
     }
     catch { /* noop */ }
 }
+function getUpgradeFailuresFile() {
+    return resolveShennianPath('upgrade-failures.json');
+}
+export function readUpgradeFailures(filePath = getUpgradeFailuresFile()) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (!parsed || typeof parsed !== 'object' || !parsed.versions)
+            return { versions: {} };
+        return { versions: parsed.versions };
+    }
+    catch {
+        return { versions: {} };
+    }
+}
+function writeUpgradeFailures(failures) {
+    fs.mkdirSync(getShennianDir(), { recursive: true });
+    fs.writeFileSync(getUpgradeFailuresFile(), JSON.stringify(failures, null, 2));
+}
+export function getUpgradeRetryDelayMs(failureCount) {
+    return RETRY_DELAYS_MS[Math.min(Math.max(failureCount - 1, 0), RETRY_DELAYS_MS.length - 1)];
+}
+export function isUpgradeVersionInCooldown(version, now = Date.now(), failures = readUpgradeFailures()) {
+    const record = failures.versions[version];
+    return Boolean(record && record.nextRetryAt > now);
+}
+export function recordUpgradeFailure(version, error, now = Date.now()) {
+    const failures = readUpgradeFailures();
+    const previous = failures.versions[version];
+    const failureCount = (previous?.failureCount ?? 0) + 1;
+    const record = {
+        version,
+        failureCount,
+        firstFailedAt: previous?.firstFailedAt ?? now,
+        lastFailedAt: now,
+        nextRetryAt: now + getUpgradeRetryDelayMs(failureCount),
+        error,
+    };
+    failures.versions[version] = record;
+    writeUpgradeFailures(failures);
+    return record;
+}
+export function clearUpgradeFailure(version) {
+    const failures = readUpgradeFailures();
+    if (!failures.versions[version])
+        return;
+    delete failures.versions[version];
+    writeUpgradeFailures(failures);
+}
 /**
  * Called on daemon startup. Detects crash loops from a failed upgrade and
  * initiates rollback if crash count exceeds threshold.
@@ -162,6 +215,7 @@ export async function handleStartupCrashCheck() {
 export async function performUpgrade(targetVersion, onProgress) {
     const currentVersion = getCurrentVersion();
     if (currentVersion === targetVersion) {
+        clearUpgradeFailure(targetVersion);
         return { ok: false, error: `Already on version ${targetVersion}` };
     }
     // Step 1: Verify npm is accessible
@@ -225,6 +279,7 @@ export async function performUpgrade(targetVersion, onProgress) {
         attemptAt: Date.now(),
     });
     cleanOldBackups();
+    clearUpgradeFailure(targetVersion);
     // 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shennian",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Shennian — AI Agent Mobile Console CLI",
   "type": "module",
   "bin": {