@xiaohhhh1/canvas-agent 0.4.5 → 0.4.7

package/dist/config.js

@@ -5,25 +5,121 @@ import path from "node:path";
 export const DEFAULT_PORT = 17371;
 export const CONFIG_DIR = path.join(os.homedir(), ".infinite-canvas");
 export const CONFIG_FILE = path.join(CONFIG_DIR, "canvas-agent.json");
+const CONFIG_BACKUP_FILE = `${CONFIG_FILE}.bak`;
+const CONFIG_LOCK_FILE = `${CONFIG_FILE}.lock`;
 export const VERSION = readPackageVersion();
 export const AGENT_PROMPT = fs.readFileSync(new URL("../agent-instructions.md", import.meta.url), "utf8");
 const initializedWorkspaces = new Set();
 /** 读取本地 Canvas Agent 配置，不存在时生成默认配置。 */
 export function loadConfig(create = false) {
-    try {
-        return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    const existing = readStoredConfig();
+    if (existing)
+        return existing;
+    if (fs.existsSync(CONFIG_FILE) || fs.existsSync(CONFIG_BACKUP_FILE)) {
+        throw new Error(`Canvas Agent configuration is unreadable: ${CONFIG_FILE}`);
     }
-    catch {
-        const config = { url: `http://127.0.0.1:${Number(process.env.PORT) || DEFAULT_PORT}`, token: crypto.randomBytes(18).toString("hex") };
-        if (create)
-            saveConfig(config);
+    const config = { url: `http://127.0.0.1:${Number(process.env.PORT) || DEFAULT_PORT}`, token: crypto.randomBytes(18).toString("hex") };
+    if (!create)
         return config;
-    }
+    return withConfigLock(() => {
+        const raced = readStoredConfig();
+        if (raced)
+            return raced;
+        writeStoredConfig(config);
+        return config;
+    });
 }
 /** 将 Canvas Agent 配置写入用户配置目录。 */
 export function saveConfig(config) {
+    withConfigLock(() => {
+        const current = readStoredConfig();
+        // The token is the durable identity used by the browser relay. A stale
+        // concurrent process may update workspace preferences, but it must never
+        // rotate that identity and strand every already-paired browser.
+        if (current?.token && current.token !== config.token)
+            config.token = current.token;
+        writeStoredConfig(config);
+    });
+}
+function readStoredConfig() {
+    return readConfigFile(CONFIG_FILE) || readConfigFile(CONFIG_BACKUP_FILE);
+}
+function readConfigFile(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (typeof value.url !== "string" || !value.url || typeof value.token !== "string" || !value.token)
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeStoredConfig(config) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    const body = JSON.stringify(config, null, 2);
+    writeAtomic(CONFIG_BACKUP_FILE, body);
+    writeAtomic(CONFIG_FILE, body);
+}
+function writeAtomic(target, body) {
+    const temporary = `${target}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, body, { encoding: "utf8", flag: "wx" });
+        try {
+            fs.renameSync(temporary, target);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EEXIST" && code !== "EPERM")
+                throw error;
+            // Windows does not consistently replace an existing file with
+            // renameSync. The backup is written first, so readers remain able
+            // to recover the durable identity during this tiny replacement.
+            fs.unlinkSync(target);
+            fs.renameSync(temporary, target);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { }
+    }
+}
+function withConfigLock(operation) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    let descriptor;
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            descriptor = fs.openSync(CONFIG_LOCK_FILE, "wx");
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - fs.statSync(CONFIG_LOCK_FILE).mtimeMs > 30_000)
+                    fs.unlinkSync(CONFIG_LOCK_FILE);
+            }
+            catch { }
+            sleepSync(10);
+        }
+    }
+    if (descriptor === undefined)
+        throw new Error("Canvas Agent configuration is busy");
+    try {
+        return operation();
+    }
+    finally {
+        fs.closeSync(descriptor);
+        try {
+            fs.unlinkSync(CONFIG_LOCK_FILE);
+        }
+        catch { }
+    }
+}
+function sleepSync(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
 }
 /** 确保站点级 Codex 工作空间存在并已初始化。 */
 export function ensureSiteWorkspace(config) {

package/dist/index.js

@@ -2,9 +2,12 @@
 import { startHttpServer } from "./server/http.js";
 import { ensureHttpServer } from "./server/ensure-http.js";
 import { startMcpServer } from "./server/mcp.js";
+import { startHttpSupervisor } from "./server/supervisor.js";
 if (process.argv[2] === "mcp") {
     await ensureHttpServer();
     await startMcpServer();
 }
+else if (process.argv[2] === "watch")
+    startHttpSupervisor();
 else
     startHttpServer();

package/dist/relay-bridge.js

@@ -1,6 +1,7 @@
 import WebSocket from "ws";
 const DEFAULT_RELAY_URL = "wss://canvas.xiaohhhh1.com/api/agent-relay";
 const RECONNECT_DELAY_MS = 3_000;
+const HEARTBEAT_INTERVAL_MS = 15_000;
 /**
  * Keeps an outbound, encrypted connection to the production relay.  The canvas
  * browser can then use same-origin requests instead of directly reaching a
@@ -12,6 +13,7 @@ export function startRelayBridge(config) {
     let socket = null;
     let stopped = false;
     let reconnectTimer = null;
+    let heartbeatTimer = null;
     const send = (message) => {
         if (socket?.readyState === WebSocket.OPEN)
             socket.send(JSON.stringify(message));
@@ -70,9 +72,17 @@ export function startRelayBridge(config) {
             return;
         try {
             socket = new WebSocket(relayUrl);
-            socket.on("open", () => send({ type: "hello", role: "agent", token: config.token }));
+            socket.on("open", () => {
+                send({ type: "hello", role: "agent", token: config.token });
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                heartbeatTimer = setInterval(() => send({ type: "heartbeat", time: Date.now() }), HEARTBEAT_INTERVAL_MS);
+            });
             socket.on("message", onMessage);
             socket.on("close", () => {
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                heartbeatTimer = null;
                 subscriptions.forEach((controller) => controller.abort());
                 subscriptions.clear();
                 if (!stopped)
@@ -89,6 +99,8 @@ export function startRelayBridge(config) {
         stopped = true;
         if (reconnectTimer)
             clearTimeout(reconnectTimer);
+        if (heartbeatTimer)
+            clearInterval(heartbeatTimer);
         subscriptions.forEach((controller) => controller.abort());
         subscriptions.clear();
         socket?.close();

package/dist/server/ensure-http.js

@@ -19,7 +19,7 @@ export async function ensureHttpServer() {
     const entry = process.argv[1];
     if (!entry)
         throw new Error("无法定位 Canvas Agent 启动文件");
-    const child = spawn(process.execPath, [entry, "serve"], { detached: true, stdio: "ignore", windowsHide: true });
+    const child = spawn(process.execPath, [entry, "watch"], { detached: true, stdio: "ignore", windowsHide: true });
     child.unref();
     for (let attempt = 0; attempt < 40; attempt += 1) {
         await new Promise((resolve) => setTimeout(resolve, 250));

package/dist/server/http.js

@@ -10,6 +10,7 @@ import { startRelayBridge } from "../relay-bridge.js";
 import { logger } from "../utils/logger.js";
 import { windowsRootExecutable, windowsSystemExecutable } from "../utils/windows.js";
 import { WorkflowManager } from "../workflow/manager.js";
+import { AGENT_REPLACED_EXIT_CODE } from "./supervisor.js";
 /** 启动仅监听本机的 Canvas Agent HTTP 服务。 */
 export function startHttpServer() {
     const config = loadConfig(true);
@@ -64,8 +65,8 @@ export function startHttpServer() {
     app.post("/agent/shutdown", (_req, res) => {
         res.json({ ok: true, version: VERSION });
         setTimeout(() => {
-            httpServer?.close(() => process.exit(0));
-            setTimeout(() => process.exit(0), 2000).unref();
+            httpServer?.close(() => process.exit(AGENT_REPLACED_EXIT_CODE));
+            setTimeout(() => process.exit(AGENT_REPLACED_EXIT_CODE), 2000).unref();
         }, 50).unref();
     });
     app.get("/events", (req, res) => session.openEvents(requestUrl(req, config), res));
@@ -270,7 +271,7 @@ export function startHttpServer() {
     httpServer = app.listen(port, "127.0.0.1", () => {
         console.log("Infinite Canvas Agent");
         console.log(`Local URL: ${config.url}`);
-        console.log(`Connect token: ${config.token}`);
+        console.log("Connect token: stored securely in the local Agent configuration");
         console.log("Codex MCP is not installed by this command.");
         console.log("Optional MCP add: codex mcp add infinite-canvas -- npx -y @xiaohhhh1/canvas-agent mcp");
         console.log("Remove manually added MCP: codex mcp remove infinite-canvas");

package/dist/server/supervisor.d.ts

@@ -0,0 +1,4 @@
+export declare const AGENT_REPLACED_EXIT_CODE = 75;
+export declare function shouldRestartAgent(code: number | null, stopping: boolean): boolean;
+/** Keep the local HTTP worker alive, but step aside when a newer package replaces it. */
+export declare function startHttpSupervisor(): void;

package/dist/server/supervisor.js

@@ -0,0 +1,38 @@
+import { spawn } from "node:child_process";
+export const AGENT_REPLACED_EXIT_CODE = 75;
+const RESTART_DELAY_MS = 1000;
+export function shouldRestartAgent(code, stopping) {
+    return !stopping && code !== AGENT_REPLACED_EXIT_CODE;
+}
+/** Keep the local HTTP worker alive, but step aside when a newer package replaces it. */
+export function startHttpSupervisor() {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error("无法定位 Canvas Agent 启动文件");
+    let child;
+    let stopping = false;
+    let restartTimer;
+    const launch = () => {
+        if (stopping)
+            return;
+        child = spawn(process.execPath, [entry, "serve"], { stdio: "ignore", windowsHide: true });
+        child.once("exit", (code) => {
+            child = undefined;
+            if (!shouldRestartAgent(code, stopping))
+                return void process.exit(0);
+            restartTimer = setTimeout(launch, RESTART_DELAY_MS);
+        });
+    };
+    const stop = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        if (restartTimer)
+            clearTimeout(restartTimer);
+        child?.kill();
+        setTimeout(() => process.exit(0), 2000).unref();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    launch();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",