@foxden-app/foxclaw 0.5.2 → 0.5.4

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.5.4 - 2026-06-04
+
+### 中文
+- 修复 `/update` 遗留 `self-update.json` pending 后永久显示“升级已经在进行中”的问题：pending 超过 15 分钟会自动转为失败状态，Telegram 会回报失败，下一次 `/update` 可以重新发起。
+- 这个补丁专门兜底 0.5.2 在 `KillMode=control-group` 下被杀掉的旧 updater，以及任何未来被外部中断、没有写完成状态的升级进程。
+
+### English
+- Fixed `/update` getting permanently stuck on "update already running" after a leftover `self-update.json` pending state: pending updates now expire as failed after 15 minutes, Telegram reports the failure, and the next `/update` can start again.
+- This specifically recovers from the 0.5.2 updater killed by `KillMode=control-group`, and from any future updater interruption that fails to write a terminal status.
+
+## 0.5.3 - 2026-06-04
+
+### 中文
+- 修复 0.5.2 中 `/update` 完成回报丢失的问题：Linux 自升级子进程现在通过独立的 user systemd transient service 运行，不再留在 `foxclaw.service` control group 里，因此 `KillMode=control-group` 重启服务时不会提前杀掉 updater。
+- 保留 `KillMode=control-group` 的 app-server 清理能力，同时让升级进程能在服务重启后继续写入完成状态，由新服务启动后的轮询发送 Telegram 成功/失败回报。
+
+### English
+- Fixed missing `/update` completion reports in 0.5.2: on Linux the self-update worker now runs in a separate user systemd transient service instead of the `foxclaw.service` control group, so `KillMode=control-group` no longer kills the updater during service restart.
+- Kept `KillMode=control-group` app-server cleanup while allowing the updater to write its final status after restart; the newly started service polls that status and sends the Telegram success/failure report.
+
 ## 0.5.2 - 2026-06-04
 
 ### 中文

package/dist/update.d.ts

@@ -1,4 +1,5 @@
 import type { AppLocale } from './types.js';
+export declare const SELF_UPDATE_PENDING_TIMEOUT_MS: number;
 export type SelfUpdateState = 'pending' | 'succeeded' | 'failed';
 export interface SelfUpdateStatus {
     state: SelfUpdateState;
@@ -31,6 +32,8 @@ interface CreateSelfUpdateRuntimeOptions {
     statusPath: string;
     logPath: string;
     codexCliBin?: string;
+    pendingTimeoutMs?: number;
+    now?: () => Date;
 }
 interface PerformSelfUpdateOptions {
     entryPoint: string;
@@ -40,6 +43,12 @@ interface PerformSelfUpdateOptions {
     codexCliBin?: string;
     env?: NodeJS.ProcessEnv;
 }
+export interface SelfUpdateLaunchCommand {
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+    viaSystemdRun: boolean;
+}
 export interface SelfUpdateOutcome {
     ok: boolean;
     fromVersion: string;
@@ -53,5 +62,16 @@ export declare function resolveCodexUpdateInstaller(codexCliBin: string, nodePat
 export declare function readSelfUpdateStatus(statusFile: string): SelfUpdateStatus | null;
 export declare function writeSelfUpdateStatus(statusFile: string, status: SelfUpdateStatus): void;
 export declare function createSelfUpdateRuntime(options: CreateSelfUpdateRuntimeOptions): SelfUpdateRuntime;
+export declare function buildSelfUpdateLaunchCommand(options: {
+    entryPoint: string;
+    nodePath: string;
+    statusFile: string;
+    logPath: string;
+    codexCliBin?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    systemdRunPath?: string | null;
+    unitName?: string;
+}): SelfUpdateLaunchCommand;
 export declare function performSelfUpdate(options: PerformSelfUpdateOptions): SelfUpdateOutcome;
 export {};

package/dist/update.js

@@ -5,6 +5,7 @@ import { spawn, spawnSync } from 'node:child_process';
 const PACKAGE_SPEC = '@foxden-app/foxclaw@latest';
 const CODEX_PACKAGE_SPEC = '@openai/codex@latest';
 const UPDATE_STATUS_FILENAME = 'self-update.json';
+export const SELF_UPDATE_PENDING_TIMEOUT_MS = 15 * 60_000;
 export function selfUpdateStatusPath(statusPath) {
     return path.join(path.dirname(statusPath), UPDATE_STATUS_FILENAME);
 }
@@ -148,11 +149,33 @@ export function writeSelfUpdateStatus(statusFile, status) {
     fs.writeFileSync(temporaryFile, `${JSON.stringify(status, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
     fs.renameSync(temporaryFile, statusFile);
 }
+function readNormalizedSelfUpdateStatus(statusFile, pendingTimeoutMs, now) {
+    const status = readSelfUpdateStatus(statusFile);
+    if (!status || status.state !== 'pending' || pendingTimeoutMs <= 0) {
+        return status;
+    }
+    const updatedAtMs = Date.parse(status.updatedAt);
+    const nowMs = now().getTime();
+    const isStale = Number.isNaN(updatedAtMs) || nowMs - updatedAtMs > pendingTimeoutMs;
+    if (!isStale) {
+        return status;
+    }
+    const failed = {
+        ...status,
+        state: 'failed',
+        error: `self-update timed out after ${Math.round(pendingTimeoutMs / 60_000)} minute(s) without writing a completion status; the previous updater may have been interrupted`,
+        updatedAt: new Date(nowMs).toISOString(),
+    };
+    writeSelfUpdateStatus(statusFile, failed);
+    return failed;
+}
 export function createSelfUpdateRuntime(options) {
     const statusFile = selfUpdateStatusPath(options.statusPath);
+    const pendingTimeoutMs = options.pendingTimeoutMs ?? SELF_UPDATE_PENDING_TIMEOUT_MS;
+    const now = options.now ?? (() => new Date());
     return {
         async launch(scopeId, locale) {
-            const current = readSelfUpdateStatus(statusFile);
+            const current = readNormalizedSelfUpdateStatus(statusFile, pendingTimeoutMs, now);
             if (current?.state === 'pending') {
                 throw new Error('A FoxClaw update is already running.');
             }
@@ -171,12 +194,33 @@ export function createSelfUpdateRuntime(options) {
             fs.mkdirSync(path.dirname(options.logPath), { recursive: true });
             const logFd = fs.openSync(options.logPath, 'a', 0o600);
             try {
-                const child = spawn(options.nodePath, [options.entryPoint, 'update', '--notification-file', statusFile], {
-                    detached: true,
-                    stdio: ['ignore', logFd, logFd],
-                    env: options.codexCliBin ? { ...process.env, CODEX_CLI_BIN: options.codexCliBin } : process.env,
+                const launch = buildSelfUpdateLaunchCommand({
+                    entryPoint: options.entryPoint,
+                    nodePath: options.nodePath,
+                    statusFile,
+                    logPath: options.logPath,
+                    ...(options.codexCliBin ? { codexCliBin: options.codexCliBin } : {}),
                 });
-                child.unref();
+                if (launch.viaSystemdRun) {
+                    const result = spawnSync(launch.command, launch.args, {
+                        stdio: ['ignore', logFd, logFd],
+                        env: launch.env,
+                    });
+                    if (result.error) {
+                        throw result.error;
+                    }
+                    if (result.status !== 0) {
+                        throw new Error(`${launch.command} ${launch.args.join(' ')} exited with status ${result.status ?? 'unknown'}.`);
+                    }
+                }
+                else {
+                    const child = spawn(launch.command, launch.args, {
+                        detached: true,
+                        stdio: ['ignore', logFd, logFd],
+                        env: launch.env,
+                    });
+                    child.unref();
+                }
             }
             catch (error) {
                 writeSelfUpdateStatus(statusFile, {
@@ -198,13 +242,47 @@ export function createSelfUpdateRuntime(options) {
             }
         },
         async readStatus() {
-            return readSelfUpdateStatus(statusFile);
+            return readNormalizedSelfUpdateStatus(statusFile, pendingTimeoutMs, now);
         },
         async clearStatus() {
             fs.rmSync(statusFile, { force: true });
         },
     };
 }
+export function buildSelfUpdateLaunchCommand(options) {
+    const env = options.codexCliBin
+        ? { ...(options.env ?? process.env), CODEX_CLI_BIN: options.codexCliBin }
+        : { ...(options.env ?? process.env) };
+    const updateArgs = [options.entryPoint, 'update', '--notification-file', options.statusFile];
+    const platform = options.platform ?? process.platform;
+    const systemdRunPath = options.systemdRunPath === undefined
+        ? resolveCommand('systemd-run', env)
+        : options.systemdRunPath;
+    if (platform === 'linux' && systemdRunPath) {
+        const unitName = options.unitName ?? `foxclaw-update-${process.pid}-${Date.now()}`;
+        return {
+            command: systemdRunPath,
+            args: [
+                '--user',
+                '--collect',
+                `--unit=${unitName}`,
+                `--property=StandardOutput=append:${options.logPath}`,
+                `--property=StandardError=append:${options.logPath}`,
+                ...systemdSetEnvArgs(env),
+                options.nodePath,
+                ...updateArgs,
+            ],
+            env,
+            viaSystemdRun: true,
+        };
+    }
+    return {
+        command: options.nodePath,
+        args: updateArgs,
+        env,
+        viaSystemdRun: false,
+    };
+}
 export function performSelfUpdate(options) {
     const env = options.env ?? process.env;
     let toVersion = null;
@@ -295,6 +373,31 @@ function executableCandidates(commandName, nodePath, env, preferred = []) {
         ...(env.PATH || '').split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, commandName)),
     ].filter((candidate, index, all) => candidate && all.indexOf(candidate) === index);
 }
+function resolveCommand(commandName, env) {
+    for (const directory of (env.PATH || '').split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(directory, commandName);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    for (const fallback of ['/usr/bin', '/bin', '/usr/local/bin']) {
+        const candidate = path.join(fallback, commandName);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function systemdSetEnvArgs(env) {
+    return Object.entries(env)
+        .filter((entry) => {
+        const [key, value] = entry;
+        return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)
+            && typeof value === 'string'
+            && !value.includes('\0');
+    })
+        .map(([key, value]) => `--setenv=${key}=${value}`);
+}
 function buildInstallerEnv(entryPoint, installer, env) {
     const pnpmHome = installer.manager === 'pnpm'
         ? installer.pnpmHome ?? inferPnpmHomeFromEntryPoint(entryPoint)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",