@iicp/client 0.7.101 → 0.7.103

package/dist/cli.js

@@ -44,6 +44,7 @@ const node_child_process_1 = require("node:child_process");
 const readline = require("node:readline/promises");
 const node_process_1 = require("node:process");
 const node_js_1 = require("./node.js");
+const runtime_health_js_1 = require("./runtime_health.js");
 const client_js_1 = require("./client.js");
 const node_log_js_1 = require("./node_log.js");
 const cip_policy_js_1 = require("./cip_policy.js");
@@ -53,6 +54,8 @@ const index_js_2 = require("./backends/index.js");
 const recovery_js_1 = require("./recovery.js");
 const identity_js_1 = require("./identity.js");
 const delegation_js_1 = require("./delegation.js");
+const operator_profile_js_1 = require("./operator_profile.js");
+const updater_js_1 = require("./updater.js");
 const mcp_policy_js_1 = require("./mcp_policy.js");
 const mcp_negotiation_js_1 = require("./mcp_negotiation.js");
 /**
@@ -170,6 +173,7 @@ function printHelp() {
         `  list                       List node configs saved under ~/.iicp/nodes/\n` +
         `  serve                      Register and serve a node\n` +
         `  doctor                     Check local health, directory presence, and recovery action\n` +
+        `  healthcheck                Check local runtime liveness/readiness snapshot\n` +
         `  query <prompt>             Discover mesh nodes and submit a chat task\n` +
         `  credits                    Show your operator wallet plus this node's credit ledger\n` +
         `  proxy                      Run the local OpenAI/Ollama/Anthropic-compat gateway (loopback; no registration)\n` +
@@ -693,18 +697,6 @@ async function runServe(opts) {
             allowCoordinator: true,
         });
     }
-    // 2-C: co-host the compat proxy on loopback alongside the node, supervised so a
-    // proxy failure logs but never drops the network-facing node. Forced to 127.0.0.1.
-    if (opts.withProxy) {
-        const pport = envInt("IICP_PROXY_PORT", 9483);
-        const pclient = new client_js_1.IicpClient({
-            directory_url: opts.directoryUrl,
-            region: opts.region,
-        });
-        const pserver = (0, index_js_1.createProxyServer)(pclient);
-        pserver.on("error", (e) => process.stderr.write(`co-hosted proxy error (node continues): ${String(e)}\n`));
-        pserver.listen(pport, "127.0.0.1", () => process.stdout.write(`co-hosted proxy → http://127.0.0.1:${pport} (OpenAI/Ollama/Anthropic compat)\n`));
-    }
     // Phase 2 (#529/#55) — capture any cached node_token so the node can prove
     // ownership on re-registration (IICP-E050 token path).
     let savedNodeToken;
@@ -717,6 +709,31 @@ async function runServe(opts) {
         savedNodeToken = saved.node_token ?? undefined;
         opts = applySavedNode(opts, saved);
     }
+    const _op = (0, identity_js_1.loadOperator)();
+    const managedDecision = (0, operator_profile_js_1.evaluateManagedOperator)({
+        mode: (process.env.IICP_OPERATOR_PROFILE ?? "convenience").trim().toLowerCase(),
+        authentication_configured: !!_op && (0, identity_js_1.operatorIsKeyBacked)(_op),
+        identity_storage_protected: !!_op && (0, identity_js_1.operatorIsKeyBacked)(_op) && (0, identity_js_1.operatorIsEncrypted)(_op),
+        auto_update_requested: (0, updater_js_1.autoUpdateEnabled)(),
+        update_authenticated: envBool("IICP_MANAGED_UPDATE_AUTHENTICATED"),
+        rollback_verified: envBool("IICP_MANAGED_ROLLBACK_VERIFIED"),
+        upnp_requested: opts.autoDetectNat && !envBool("IICP_SKIP_UPNP"),
+        tunnel_requested: opts.tunnel !== false,
+        upnp_approved: envBool("IICP_MANAGED_UPNP_APPROVED"),
+        tunnel_approved: envBool("IICP_MANAGED_TUNNEL_APPROVED"),
+    });
+    if (!managedDecision.accepted) {
+        process.stderr.write(`ERROR: managed operator startup rejected: ${managedDecision.reason}\n`);
+        return 2;
+    }
+    // Start the optional co-hosted listener only after the operator profile passes.
+    if (opts.withProxy) {
+        const pport = envInt("IICP_PROXY_PORT", 9483);
+        const pclient = new client_js_1.IicpClient({ directory_url: opts.directoryUrl, region: opts.region });
+        const pserver = (0, index_js_1.createProxyServer)(pclient);
+        pserver.on("error", (e) => process.stderr.write(`co-hosted proxy error (node continues): ${String(e)}\n`));
+        pserver.listen(pport, "127.0.0.1", () => process.stdout.write(`co-hosted proxy → http://127.0.0.1:${pport} (OpenAI/Ollama/Anthropic compat)\n`));
+    }
     // #410/#414 — built-in backend-url fallback applied LAST (after flag/env/saved-config),
     // so a bare `serve --model x` works without --backend-url. An `anthropic` backend
     // defaults to the Anthropic API, not localhost Ollama. Mirrors Python cli.py ~704.
@@ -984,7 +1001,6 @@ async function runServe(opts) {
     // #463/#464 — bind the operator identity: issue a delegation FROM the (key-backed) operator
     // identity for this node and advertise the public display_name. The directory verifies the
     // delegation (operator_pub == operator_id) and records the operator. Never sends the secret/contact.
-    const _op = (0, identity_js_1.loadOperator)();
     let _opDelegation;
     let _opDisplayName;
     let _opCreatedAt;
@@ -1959,6 +1975,50 @@ async function runDoctor(argv) {
     process.stdout.write("  Note                    restart is automatic only when supervised services set IICP_SUPERVISED=1\n");
     return 0;
 }
+function runHealthcheck(argv) {
+    const { values } = safeParseArgs({ args: argv, options: { node: { type: "string" }, json: { type: "boolean" }, ready: { type: "boolean" }, help: { type: "boolean", short: "h" } }, allowPositionals: false });
+    if (values.help) {
+        process.stdout.write("usage: iicp-node healthcheck --node NAME [--json] [--ready]\n");
+        return 0;
+    }
+    const node = values.node ?? process.env.IICP_NODE_NAME;
+    if (!node) {
+        process.stderr.write("ERROR: healthcheck requires --node NAME\n");
+        return 2;
+    }
+    let file;
+    try {
+        file = (0, runtime_health_js_1.runtimeHealthPath)(node);
+    }
+    catch (error) {
+        process.stderr.write(`ERROR: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 2;
+    }
+    let snapshot;
+    try {
+        snapshot = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        process.stderr.write(`INDETERMINATE: runtime-health snapshot unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+        return 2;
+    }
+    const progress = snapshot.progress;
+    const staleAfter = Number(progress?.runtime?.stale_after_ms ?? 0);
+    const age = Date.now() - fs.statSync(file).mtimeMs;
+    if (age < 0 || !Number.isFinite(staleAfter) || staleAfter <= 0) {
+        process.stderr.write("INDETERMINATE: snapshot freshness could not be established\n");
+        return 2;
+    }
+    if (values.json)
+        process.stdout.write(`${JSON.stringify(snapshot, null, 2)}\n`);
+    else
+        process.stdout.write(`IICP node health — ${node}\n  liveness   ${String(snapshot.liveness ?? "indeterminate")}\n  readiness  ${String(snapshot.readiness ?? "not_ready")}\n  reasons    ${Array.isArray(snapshot.reason_codes) ? snapshot.reason_codes.join(", ") : ""}\n`);
+    if (age > staleAfter)
+        return 1;
+    if (values.ready)
+        return snapshot.readiness === "ready" ? 0 : 1;
+    return snapshot.liveness === "live" ? 0 : snapshot.liveness === "not_live" ? 1 : 2;
+}
 /**
  * Resolve a passphrase: $IICP_OPERATOR_PASSPHRASE if set (headless/CI), else an interactive
  * readline prompt (this command is operator-run, so a prompt is fine here — only `serve` must
@@ -2687,22 +2747,126 @@ async function runMcpGateway(argv) {
         }
     }
     let mcpRpcId = 0;
-    async function callMcp(toolName, args) {
+    let legacySessionId;
+    let legacyInitialization;
+    class McpLegacySessionExpired extends Error {
+    }
+    async function mcpResponseJson(response) {
+        const raw = await response.text();
+        if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+            const events = raw.split(/\r?\n/).filter((line) => line.startsWith("data: ")).map((line) => line.slice(6));
+            if (!events.length)
+                throw new Error("MCP server returned an empty event stream");
+            return JSON.parse(events.at(-1) ?? "");
+        }
+        return JSON.parse(raw);
+    }
+    async function initializeLegacySession() {
+        if (legacyInitialization)
+            return legacyInitialization;
+        legacyInitialization = (async () => {
+            const id = ++mcpRpcId;
+            const headers = {
+                "Content-Type": "application/json",
+                "MCP-Protocol-Version": mcp_negotiation_js_1.LEGACY_MCP_REVISION,
+                "Accept": "application/json, text/event-stream",
+            };
+            const init = await fetch(`${mcpUrl}/mcp`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    jsonrpc: "2.0", id, method: "initialize",
+                    params: { protocolVersion: mcp_negotiation_js_1.LEGACY_MCP_REVISION, capabilities: {}, clientInfo: { name: "iicp-mcp-gateway", version: "0.7" } },
+                }),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!init.ok)
+                throw new Error(`MCP legacy initialization failed: ${init.status}`);
+            const initData = await mcpResponseJson(init);
+            if (initData["error"])
+                throw new Error("MCP server rejected legacy initialization");
+            const sessionId = init.headers.get("mcp-session-id");
+            if (!sessionId)
+                throw new Error("MCP server did not return a legacy session identifier");
+            const initialized = await fetch(`${mcpUrl}/mcp`, {
+                method: "POST",
+                headers: { ...headers, "Mcp-Session-Id": sessionId },
+                body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!initialized.ok)
+                throw new Error(`MCP legacy initialized notification failed: ${initialized.status}`);
+            legacySessionId = sessionId;
+        })();
+        try {
+            await legacyInitialization;
+        }
+        finally {
+            legacyInitialization = undefined;
+        }
+    }
+    async function legacyToolCall(rpc, replaySafe) {
+        if (!legacySessionId)
+            await initializeLegacySession();
+        const send = async () => {
+            if (!legacySessionId)
+                throw new Error("legacy MCP session identifier is unavailable");
+            const response = await fetch(`${mcpUrl}/mcp`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "MCP-Protocol-Version": mcp_negotiation_js_1.LEGACY_MCP_REVISION,
+                    "Mcp-Session-Id": legacySessionId,
+                    "Accept": "application/json, text/event-stream",
+                },
+                body: JSON.stringify(rpc),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (response.status === 401 || response.status === 404) {
+                legacySessionId = undefined;
+                throw new McpLegacySessionExpired("MCP legacy session expired");
+            }
+            if (!response.ok)
+                throw new Error(`MCP server unreachable: ${response.status}`);
+            return mcpResponseJson(response);
+        };
+        try {
+            return await send();
+        }
+        catch (error) {
+            if (!(error instanceof McpLegacySessionExpired))
+                throw error;
+            if (!replaySafe)
+                throw new McpLegacySessionExpired("MCP legacy session expired; caller retry required");
+            await initializeLegacySession();
+            try {
+                return await send();
+            }
+            catch (retryError) {
+                if (retryError instanceof McpLegacySessionExpired)
+                    throw new Error("MCP legacy session expired after one reinitialization");
+                throw retryError;
+            }
+        }
+    }
+    async function callMcp(toolName, args, replaySafe = false) {
         mcpRpcId += 1;
         const params = { name: toolName, arguments: args };
         const modern = mcpRevision === mcp_negotiation_js_1.MODERN_MCP_REVISION
             ? (0, mcp_negotiation_js_1.buildModernMcpRequest)({ requestId: mcpRpcId, method: "tools/call", name: toolName, params, extensions: mcpExtensions })
             : null;
         const rpc = modern?.body ?? { jsonrpc: "2.0", id: mcpRpcId, method: "tools/call", params };
-        const resp = await fetch(`${mcpUrl}/mcp`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", ...(modern?.headers ?? {}) },
-            body: JSON.stringify(rpc),
-            signal: AbortSignal.timeout(30_000),
-        });
-        if (!resp.ok)
-            throw new Error(`MCP server unreachable: ${resp.status}`);
-        const data = await resp.json();
+        const data = modern
+            ? await (async () => {
+                const resp = await fetch(`${mcpUrl}/mcp`, {
+                    method: "POST", headers: { "Content-Type": "application/json", ...modern.headers },
+                    body: JSON.stringify(rpc), signal: AbortSignal.timeout(30_000),
+                });
+                if (!resp.ok)
+                    throw new Error(`MCP server unreachable: ${resp.status}`);
+                return resp.json();
+            })()
+            : await legacyToolCall(rpc, replaySafe);
         if (modern)
             (0, mcp_negotiation_js_1.validateModernMcpResponse)(data, mcpServerName);
         if (data["error"])
@@ -2780,15 +2944,15 @@ async function runMcpGateway(argv) {
             }
             const taskId = body["task_id"] ?? (0, node_crypto_1.randomUUID)();
             try {
-                const result = await callMcp(toolName, args);
+                const result = await callMcp(toolName, args, payload["mcp_replay_safe"] === true);
                 res.writeHead(200, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ task_id: taskId, status: "completed", result, policy_receipt: toolPolicy.receipt(toolName, "allowed", argumentCount) }));
             }
             catch (err) {
                 const msg = err.message ?? "error";
-                const code = msg.includes("unreachable") ? 502 : 422;
+                const code = err instanceof McpLegacySessionExpired ? 409 : msg.includes("unreachable") ? 502 : 422;
                 res.writeHead(code, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: msg }));
+                res.end(JSON.stringify(err instanceof McpLegacySessionExpired ? { error: "mcp_session_expired_retry_required", retryable: true } : { error: msg }));
             }
             return;
         }
@@ -2846,7 +3010,8 @@ async function runService(argv) {
             `  --node NAME        Saved node name to serve (required)\n` +
             `  --name NAME        Override service label/unit name\n` +
             `  --platform KIND    auto | launchd | systemd (default auto)\n` +
-            `  --dry-run          For install: print the generated unit without writing files\n`);
+            `  --no-start         Install and enable without starting the service\n` +
+            `  --dry-run          Print unit/actions without changing files or service state\n`);
         return subcmd ? 0 : 2;
     }
     if (!["install", "status", "restart", "uninstall"].includes(subcmd)) {
@@ -2859,6 +3024,7 @@ async function runService(argv) {
             name: { type: "string" },
             platform: { type: "string" },
             "dry-run": { type: "boolean" },
+            "no-start": { type: "boolean" },
             help: { type: "boolean", short: "h" },
         },
         allowPositionals: false,
@@ -2868,17 +3034,37 @@ async function runService(argv) {
     const node = values.node;
     if (!node)
         throw new CliError("service requires --node NAME");
-    const { renderServiceUnit } = await import("./service.js");
+    const { managerActions, renderServiceUnit } = await import("./service.js");
     const unit = renderServiceUnit(node, values.name, values.platform ?? "auto");
+    const dryRun = values["dry-run"] === true;
+    const noStart = values["no-start"] === true;
+    const printAction = (command, args) => process.stdout.write(`$ ${[command, ...args].map((part) => JSON.stringify(part)).join(" ")}\n`);
+    const execute = (operation) => {
+        for (const action of managerActions(unit, operation, noStart)) {
+            if (dryRun) {
+                printAction(action.command, action.args);
+                continue;
+            }
+            const result = (0, node_child_process_1.spawnSync)(action.command, action.args, { stdio: "inherit" });
+            if (result.error && !action.tolerateFailure)
+                throw new CliError(`${action.command} failed: ${result.error.message}`);
+            if ((result.status ?? (result.error ? 1 : 0)) !== 0 && !action.tolerateFailure) {
+                throw new CliError(`${action.command} exited with status ${result.status ?? "unknown"}`);
+            }
+        }
+    };
     if (subcmd === "install") {
-        if (values["dry-run"]) {
+        if (dryRun) {
             process.stdout.write(`# ${unit.platform} service: ${unit.name}\n# path: ${unit.path}\n${unit.content}`);
         }
         else {
             fs.mkdirSync(path.dirname(unit.path), { recursive: true });
-            fs.writeFileSync(unit.path, unit.content);
+            const temporary = `${unit.path}.tmp-${process.pid}`;
+            fs.writeFileSync(temporary, unit.content, { mode: 0o600 });
+            fs.renameSync(temporary, unit.path);
             process.stdout.write(`Installed ${unit.platform} service unit: ${unit.path}\n`);
         }
+        execute("install");
         process.stdout.write(`status:   ${unit.statusHint}\n`);
         process.stdout.write(`restart:  ${unit.restartHint}\n`);
         process.stdout.write(`logs:     ${unit.logHint}\n`);
@@ -2886,11 +3072,25 @@ async function runService(argv) {
         return 0;
     }
     if (subcmd === "status")
-        process.stdout.write(`${unit.statusHint}\n`);
+        execute("status");
     if (subcmd === "restart")
-        process.stdout.write(`${unit.restartHint}\n`);
-    if (subcmd === "uninstall")
-        process.stdout.write(`${unit.uninstallHint}\n`);
+        execute("restart");
+    if (subcmd === "uninstall") {
+        execute("uninstall");
+        if (dryRun)
+            process.stdout.write(`$ ${JSON.stringify("rm")} ${JSON.stringify("-f")} ${JSON.stringify(unit.path)}\n`);
+        else
+            fs.rmSync(unit.path, { force: true });
+        if (unit.platform === "systemd") {
+            if (dryRun)
+                printAction("systemctl", ["--user", "daemon-reload"]);
+            else {
+                const result = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+                if (result.error || result.status !== 0)
+                    throw new CliError("systemctl --user daemon-reload failed after uninstall");
+            }
+        }
+    }
     return 0;
 }
 async function dispatch(argv) {
@@ -2905,6 +3105,8 @@ async function dispatch(argv) {
         return runCredits(argv.slice(1));
     if (cmd === "doctor")
         return runDoctor(argv.slice(1));
+    if (cmd === "healthcheck")
+        return runHealthcheck(argv.slice(1));
     if (cmd === "operator")
         return runOperator(argv.slice(1));
     if (cmd === "proxy")