@wirecat/cli-core 0.463.0 → 0.464.0

package/dist/cli/upgrade-command.js

@@ -2,19 +2,25 @@ import { spawnSync } from "node:child_process";
 import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
+import { restartMcpServers, staleMcpSessions, thisSystem, } from "../background/after-upgrade.js";
 import { servingProfiles } from "../background/lock.js";
-import { upgradePackage } from "../services/package-upgrade.js";
+import { upgradePackage, } from "../services/package-upgrade.js";
+import { environmentOf } from "./context.js";
 import { grantsAuthority, LOCAL_WRITE } from "./effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { usableProfileName } from "./profile.js";
+/** `server restart` waits 30 s for serve to stop and 30 s for it to listen; this is a ceiling over both. */
+const RESTART_CEILING_MS = 90_000;
+const TIMEOUT_EXIT = 9;
 /**
  * A running serve keeps the code it started with; the update replaced the files under it. Each is restarted by
- * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`.
- * `spawn` replaces the child process, as in `UpdateEnvironment`.
+ * the new `script` — `server restart` refuses a serve started by hand, which is then named in `left`, and one that
+ * ran out of time is named in `timedOut` too. `spawn` replaces the child process, as in `UpdateEnvironment`.
  */
 export const restartServers = (app, script, env, spawn) => {
     const restarted = [];
     const left = [];
+    const timedOut = [];
     for (const profile of servingProfiles(app, env)) {
         try {
             usableProfileName(profile);
@@ -25,11 +31,40 @@ export const restartServers = (app, script, env, spawn) => {
         const argv = [script, profile, "server", "restart"];
         const code = spawn
             ? spawn([process.execPath, ...argv])
-            : (spawnSync(process.execPath, argv, { env, shell: false, stdio: ["ignore", 2, 2] }).status ?? 1);
+            : (spawnSync(process.execPath, argv, {
+                env,
+                shell: false,
+                stdio: ["ignore", 2, 2],
+                timeout: RESTART_CEILING_MS,
+            }).status ?? TIMEOUT_EXIT);
         (code === 0 ? restarted : left).push(profile);
+        if (code === TIMEOUT_EXIT)
+            timedOut.push(profile);
     }
-    return { restarted, left };
+    return timedOut.length > 0 ? { restarted, left, timedOut } : { restarted, left };
 };
+const RESTART_FROM_APP = "restart them from your agent app (start a new chat, or reload its MCP servers)";
+const mcpWarnings = (command, current, servers, stale) => [
+    ...servers.flatMap((server) => !server.restarted
+        ? [`the HTTP MCP server ${server.name} (PID ${server.pid}) was not restarted: ${server.reason}`]
+        : server.to !== null && server.to === server.from
+            ? [
+                `the HTTP MCP server ${server.name} came back on ${command} ${server.to}: it runs from another install than the one upgraded`,
+            ]
+            : []),
+    ...(stale === undefined
+        ? []
+        : !stale.checked
+            ? [
+                `could not check for MCP sessions over stdio (${stale.reason}); any that run keep ${command} ${current} or older — ${RESTART_FROM_APP}`,
+            ]
+            : stale.sessions.length > 0
+                ? [
+                    `${stale.sessions.length} MCP ${stale.sessions.length === 1 ? "session" : "sessions"} over stdio still ${stale.sessions.length === 1 ? "runs" : "run"} ${command} ${current} or older ` +
+                        `(PID ${stale.sessions.map((session) => session.pid).join(", ")}) — ${RESTART_FROM_APP}`,
+                ]
+                : []),
+];
 export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(annotate(new Command("upgrade"), {
     effects: LOCAL_WRITE,
     offline: false,
@@ -42,7 +77,19 @@ export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(
         throw new CliError("validation_error", `\`${app.command} upgrade\` asks npm for the newest version; not with --offline`);
     const context = contextFor(this);
     const { renderer } = context;
-    const { result, reason, left } = await upgradePackage({ current: app.version, command: app.command, packageName, check: check === true }, { ...context, onInstall: (argv) => renderer.note(`running: ${argv.join(" ")}`) });
+    const environment = environmentOf(this);
+    const env = environment.env ?? process.env;
+    // Built before the install: after it, the old process may no longer find its own lazily loaded files.
+    const system = { ...thisSystem(packageName, app.command), ...environment.afterUpgrade };
+    const afterUpdate = async () => {
+        const servers = (await context.afterUpdate?.()) ?? { restarted: [], left: [] };
+        return {
+            ...servers,
+            mcpServers: await restartMcpServers(app, env, system),
+            staleSessions: staleMcpSessions(system),
+        };
+    };
+    const { result, reason, left, timedOut } = await upgradePackage({ current: app.version, command: app.command, packageName, check: check === true }, { ...context, afterUpdate, onInstall: (argv) => renderer.note(`running: ${argv.join(" ")}`) });
     if (reason === "held_back" && result.heldBack)
         renderer.warn(heldBackAdvice(result, result.heldBack));
     if (reason === "unavailable")
@@ -58,9 +105,14 @@ export const upgradeCommand = (app, packageName, contextFor) => grantsAuthority(
         renderer.warn(advice);
     }
     for (const profile of left) {
-        renderer.warn(`the server for profile ${profile} still runs ${app.command} ${app.version} — ` +
-            `\`${app.command} ${profile} server restart\``);
+        renderer.warn(timedOut?.includes(profile)
+            ? `the server for profile ${profile} did not restart in time and may still run ${app.command} ${app.version} — ` +
+                `\`${app.command} ${profile} server status\``
+            : `the server for profile ${profile} still runs ${app.command} ${app.version} — ` +
+                `\`${app.command} ${profile} server restart\``);
     }
+    for (const line of mcpWarnings(app.command, app.version, result.mcpServers ?? [], result.staleSessions))
+        renderer.warn(line);
     renderAnswer(this, context, itemOf(snakeKeys(result)), () => summary(app.command, result));
 });
 const heldBackAdvice = ({ installed, latest, installer }, { until, command }) => {
@@ -75,7 +127,11 @@ const summary = (command, result) => {
         const servers = result.restarted.length > 0
             ? `; restarted the server for ${result.restarted.map((profile) => `profile ${profile}`).join(", ")}`
             : "";
-        return `${command} ${result.current} → ${result.installed ?? result.latest}${held}${servers}`;
+        const mcp = (result.mcpServers ?? []).filter((server) => server.restarted);
+        const http = mcp.length > 0
+            ? `; restarted the HTTP MCP server ${mcp.map((server) => `${server.name} (${server.from ?? "?"} → ${server.to ?? "?"})`).join(", ")}`
+            : "";
+        return `${command} ${result.current} → ${result.installed ?? result.latest}${held}${servers}${http}`;
     }
     if (held)
         return `${command} ${result.current}${held}`;

package/dist/entities/fields.d.ts

@@ -7,6 +7,8 @@ export declare const time: v.SchemaWithPipe<readonly [v.StringSchema<undefined>,
 /** A time a caller sends: any offset, read as the moment it names. Answers carry `time`, always UTC. */
 export declare const zonedTime: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time with a zone">]>;
 export declare const count: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+/** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
+export declare const untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 export declare const providerMetadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, undefined>;
 export declare const author: v.StrictObjectSchema<{
     readonly type: v.PicklistSchema<["person", "bot"], undefined>;

package/dist/entities/fields.js

@@ -7,6 +7,8 @@ export const time = isoTime;
 /** A time a caller sends: any offset, read as the moment it names. Answers carry `time`, always UTC. */
 export const zonedTime = v.pipe(v.string(), v.isoTimestamp("an ISO 8601 time with a zone"));
 export const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+/** Fields of an answer item someone other than the owner wrote, as dotted paths: an agent reads them as data. */
+export const untrusted = v.optional(v.array(text));
 export const providerMetadata = v.optional(v.record(v.string(), v.unknown()));
 export const author = v.strictObject({
     type: v.picklist(["person", "bot"]),

package/dist/entities/hit.d.ts

@@ -22,6 +22,6 @@ export declare const hit: v.StrictObjectSchema<{
     readonly scope: v.OptionalSchema<v.PicklistSchema<["transcript", "chat", "summary"], undefined>, undefined>;
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
-    /** An event hit's fields that whoever sent the invitation wrote: an agent reads them as data. */
+    /** Absent on a note hit: the owner wrote it. */
     readonly untrusted: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
 }, undefined>;

package/dist/entities/hit.js

@@ -1,5 +1,5 @@
 import * as v from "valibot";
-import { count, reference, text, time } from "./fields.js";
+import { count, reference, text, time, untrusted } from "./fields.js";
 /** One result of `search all`: a message, a mail, a note, a calendar event or a meeting passage, best first. */
 export const hit = v.strictObject({
     kind: v.picklist(["message", "mail", "note", "document", "event", "meeting"]),
@@ -23,6 +23,6 @@ export const hit = v.strictObject({
     scope: v.optional(v.picklist(["transcript", "chat", "summary"])),
     /** A meeting passage's stored line, so two passages of one meeting stay apart; `search meetings` gives the same. */
     id: v.optional(v.pipe(v.string(), v.minLength(1))),
-    /** An event hit's fields that whoever sent the invitation wrote: an agent reads them as data. */
-    untrusted: v.optional(v.array(text)),
+    /** Absent on a note hit: the owner wrote it. */
+    untrusted,
 });