wikimemory 0.2.3 → 0.2.5

package/dist/npm-cli/scripts/cli.js

@@ -5,6 +5,7 @@ import { WIKIMEMORY_VERSION } from "../src/version.js";
 import { deploymentArguments, installArguments } from "./cli-options.js";
 import { deploymentPaths } from "./deployment-record.js";
 import { packageRoot } from "./package-root.js";
+import { conciseError } from "./subprocess.js";
 const [command, ...args] = process.argv.slice(2);
 function usage() {
     return `Wikimemory ${WIKIMEMORY_VERSION}\nPersonal, passkey-protected memory for Claude, Codex, and other MCP clients.\n\nUsage: wikimemory COMMAND [OPTIONS]\n\nStart a personal Cloudflare-hosted instance:\n  npx --yes wikimemory install\n\nTry it locally without a Cloudflare deployment:\n  npx --yes wikimemory dev\n\nCommands:\n  wikimemory install [--deployment NAME] [installer options]\n  wikimemory recover [--deployment NAME]\n  wikimemory dev [wrangler dev options]\n  wikimemory status [--deployment NAME]\n  wikimemory upgrade [--deployment NAME] [--yes]\n  wikimemory passkeys [--deployment NAME] list|add|revoke\n  wikimemory connect [--deployment NAME] codex|claude\n  wikimemory skills install codex|claude\n  wikimemory uninstall [--deployment NAME] [--apply]\n  wikimemory --version\n\nUse \`wikimemory COMMAND --help\` for command-specific options.`;
@@ -74,6 +75,6 @@ async function main() {
         throw new Error(`Unknown command: ${command}`);
 }
 main().catch((error) => {
-    console.error(`Wikimemory failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    console.error(`Wikimemory failed: ${conciseError(error)}`);
     process.exitCode = 1;
 });

package/dist/npm-cli/scripts/client-tools.js

@@ -1,24 +1,19 @@
-import { spawn } from "node:child_process";
 import { cp, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { deploymentRecordPath, readDeploymentRecord } from "./deployment-record.js";
+import { commandFailureMessage, runCommand } from "./subprocess.js";
 function client(value) {
     if (value === "codex" || value === "claude")
         return value;
     throw new Error("Client must be codex or claude");
 }
-async function run(command, args) {
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, { stdio: "inherit" });
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`${command} exited with status ${code ?? "unknown"}`));
-        });
+async function run(command, args, interactive = false) {
+    const result = await runCommand(command, args, {
+        ...(interactive ? { forwardLimitBytes: 4000, inheritStdin: true } : {})
     });
+    if (result.exitCode !== 0)
+        throw new Error(commandFailureMessage(`${command} client configuration`, result));
 }
 export async function connectClient(deployment, selected) {
     const target = client(selected);
@@ -26,7 +21,8 @@ export async function connectClient(deployment, selected) {
     const endpoint = `${record.origin}/mcp`;
     if (target === "codex") {
         await run("codex", ["mcp", "add", deployment, "--url", endpoint]);
-        await run("codex", ["mcp", "login", deployment, "--scopes", "memory:read,memory:write"]);
+        console.log("Complete authorization in your browser…");
+        await run("codex", ["mcp", "login", deployment, "--scopes", "memory:read,memory:write"], true);
     }
     else {
         await run("claude", [
@@ -39,8 +35,10 @@ export async function connectClient(deployment, selected) {
             deployment,
             endpoint
         ]);
-        await run("claude", ["mcp", "login", deployment]);
+        console.log("Complete authorization in your browser…");
+        await run("claude", ["mcp", "login", deployment], true);
     }
+    console.log(`Connected ${target} to ${deployment}.`);
 }
 export async function installSkills(packageRoot, selected) {
     const target = client(selected);

package/dist/npm-cli/scripts/dev.js

@@ -1,6 +1,6 @@
-import { spawn } from "node:child_process";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { commandFailureMessage, runCommand } from "./subprocess.js";
 export function localConfig(packageRoot) {
     return `${JSON.stringify({
         $schema: join(packageRoot, "node_modules", "wrangler", "config-schema.json"),
@@ -27,24 +27,19 @@ export function localConfig(packageRoot) {
     }, null, 2)}\n`;
 }
 async function runWrangler(args, inherited = false) {
-    await new Promise((resolvePromise, reject) => {
-        const child = spawn("npx", ["wrangler", ...args], {
-            stdio: inherited ? "inherit" : ["ignore", "inherit", "inherit"]
-        });
-        child.on("error", reject);
-        child.on("close", (code) => {
-            if (code === 0)
-                resolvePromise();
-            else
-                reject(new Error(`Wrangler exited with status ${code ?? "unknown"}`));
-        });
+    const result = await runCommand("npx", ["wrangler", ...args], {
+        ...(inherited ? { forwardLimitBytes: 8000, inheritStdin: true } : {})
     });
+    if (result.exitCode !== 0)
+        throw new Error(commandFailureMessage("Wrangler", result));
 }
 export async function runDev(packageRoot, args) {
     const stateDirectory = resolve(".wikimemory", "dev");
     await mkdir(stateDirectory, { recursive: true });
     const configPath = join(stateDirectory, "wrangler.jsonc");
     await writeFile(configPath, localConfig(packageRoot), "utf8");
+    console.log("Preparing local database…");
     await runWrangler(["d1", "migrations", "apply", "wikimemory", "--local", "--config", configPath]);
+    console.log("Starting local Wikimemory…");
     await runWrangler(["dev", "--config", configPath, ...args], true);
 }

package/dist/npm-cli/scripts/passkeys.js

@@ -7,6 +7,7 @@ import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { passkeyRuntime } from "./lifecycle-runtime.js";
 import { configuredOrigin } from "./setup.js";
+import { conciseError } from "./subprocess.js";
 const PRODUCTION_CONFIG = passkeyRuntime.config;
 const CLI_STATE = passkeyRuntime.client;
 const CALLBACK = "http://127.0.0.1:45831/callback";
@@ -191,7 +192,7 @@ export async function runPasskeys(args) {
 const entrypoint = process.argv[1];
 if (entrypoint !== undefined && import.meta.url === pathToFileURL(entrypoint).href) {
     runPasskeys(process.argv.slice(2)).catch((error) => {
-        console.error(`Passkey command failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        console.error(`Passkey command failed: ${conciseError(error)}`);
         process.exitCode = 1;
     });
 }

package/dist/npm-cli/scripts/setup.js

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { constants } from "node:fs";
 import { access, mkdtemp, readdir, readFile, rm, unlink, writeFile } from "node:fs/promises";
@@ -11,6 +10,8 @@ import { z } from "zod";
 import { WIKIMEMORY_VERSION } from "../src/version.js";
 import { deploymentRecordFromConfig, writeDeploymentRecord } from "./deployment-record.js";
 import { installedRecordPath, packageRoot, setupRuntime } from "./lifecycle-runtime.js";
+import { commandFailureMessage, conciseError, runCommand } from "./subprocess.js";
+export { commandFailureMessage } from "./subprocess.js";
 const PACKAGE_ROOT = packageRoot;
 const CONFIG_PATH = setupRuntime.config;
 const STATE_PATH = setupRuntime.progress;
@@ -55,16 +56,6 @@ function cloudflareOperation(args) {
         return "KV namespace creation";
     return `Cloudflare ${command}`;
 }
-function conciseDiagnostic(result) {
-    const raw = result.stderr.trim() || result.stdout.trim();
-    const plain = raw.replaceAll("\u001b", "").replaceAll(/\s+/gu, " ").trim();
-    if (plain === "")
-        return `process exited with status ${result.exitCode}`;
-    return plain.length > 600 ? `${plain.slice(0, 597)}...` : plain;
-}
-export function commandFailureMessage(operation, result) {
-    return `${operation} failed: ${conciseDiagnostic(result)}`;
-}
 async function sleep(milliseconds) {
     await new Promise((resolve) => {
         setTimeout(resolve, milliseconds);
@@ -146,44 +137,18 @@ async function exists(path) {
     }
 }
 async function run(command, args, input, allowFailure = false) {
-    const result = await new Promise((resolve, reject) => {
-        const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-        child.on("close", (code) => {
-            resolve({ stdout, stderr, exitCode: code ?? -1 });
-        });
-        child.stdin.end(input === undefined ? undefined : `${input}\n`);
-    });
+    const result = await runCommand(command, args, { ...(input === undefined ? {} : { input }) });
     if (result.exitCode !== 0 && !allowFailure)
         throw new Error(commandFailureMessage(cloudflareOperation(args), result));
     return result;
 }
 async function runInteractive(command, args) {
-    console.log(`\n> ${command} ${args.join(" ")}`);
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, { stdio: "inherit" });
-        child.on("error", (error) => {
-            reject(error);
-        });
-        child.on("close", (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`${command} exited with status ${code ?? "unknown"}`));
-        });
+    const result = await runCommand(command, args, {
+        forwardLimitBytes: 4000,
+        inheritStdin: true
     });
+    if (result.exitCode !== 0)
+        throw new Error(commandFailureMessage(cloudflareOperation(args), result));
 }
 export function initialConfig(options, account) {
     return `${JSON.stringify({
@@ -504,7 +469,6 @@ async function finalizeDeployment(options) {
     const deploymentRecord = deploymentRecordFromConfig(finalConfig, WIKIMEMORY_VERSION, options.kvName);
     const recordPath = installedRecordPath(options.workerName);
     await writeDeploymentRecord(deploymentRecord, recordPath);
-    console.log(`\nSaved deployment record: ${recordPath}`);
     console.log(`\n${handoff(origin, secret.raw, options.workerName)}`);
 }
 async function freshDeployment(options) {
@@ -602,7 +566,7 @@ export async function runSetup(args) {
 const entrypoint = process.argv[1];
 if (entrypoint !== undefined && import.meta.url === pathToFileURL(entrypoint).href) {
     runSetup(process.argv.slice(2)).catch((error) => {
-        console.error(`\nSetup failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        console.error(`\nSetup failed: ${conciseError(error)}`);
         process.exitCode = 1;
     });
 }

package/dist/npm-cli/scripts/status.js

@@ -45,5 +45,11 @@ export async function deploymentStatus(deployment) {
 }
 export async function runStatus(deployment) {
     const status = await deploymentStatus(deployment);
-    console.log(`Wikimemory deployment: ${status.deployment}\n  Account: ${status.accountId}\n  Worker: ${status.workerName}\n  D1: ${status.database}\n  KV: ${status.kvNamespace}\n  Origin: ${status.origin}\n  Recorded version: ${status.recordedVersion}\n  Running version: ${status.runningVersion}\n  Schema: ${status.schemaVersion}`);
+    console.log(statusSummary(status));
+}
+export function statusSummary(status) {
+    const mismatch = status.recordedVersion === status.runningVersion
+        ? ""
+        : `\nLocal record: ${status.recordedVersion} (run wikimemory upgrade to reconcile)`;
+    return `Wikimemory ${status.deployment}: ready\nURL: ${status.origin}\nVersion: ${status.runningVersion}\nDatabase: up to date.${mismatch}`;
 }

package/dist/npm-cli/scripts/subprocess.js

@@ -0,0 +1,74 @@
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { stripVTControlCharacters } from "node:util";
+export function boundedOutputChunk(chunk, remaining) {
+    const visible = chunk.slice(0, remaining);
+    return {
+        visible,
+        remaining: Math.max(0, remaining - visible.length),
+        truncated: visible.length < chunk.length
+    };
+}
+function forwardBounded(destination, chunk, state) {
+    const limited = boundedOutputChunk(chunk, state.remaining);
+    if (limited.visible !== "")
+        destination.write(limited.visible);
+    state.remaining = limited.remaining;
+    if (limited.truncated && !state.suppressed) {
+        destination.write("\n… additional command output suppressed.\n");
+        state.suppressed = true;
+    }
+}
+export async function runCommand(command, args, options = {}) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: [options.inheritStdin === true ? "inherit" : "pipe", "pipe", "pipe"]
+        });
+        if (child.stdout === null || child.stderr === null) {
+            child.kill();
+            reject(new Error("Subprocess output pipes were not created"));
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        const stdoutForward = { remaining: options.forwardLimitBytes ?? 0, suppressed: false };
+        const stderrForward = { remaining: options.forwardLimitBytes ?? 0, suppressed: false };
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+            if (options.forwardLimitBytes !== undefined)
+                forwardBounded(process.stdout, chunk, stdoutForward);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            if (options.forwardLimitBytes !== undefined)
+                forwardBounded(process.stderr, chunk, stderrForward);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ stdout, stderr, exitCode: code ?? -1 });
+        });
+        if (child.stdin !== null)
+            child.stdin.end(options.input === undefined ? undefined : `${options.input}\n`);
+    });
+}
+export function conciseDiagnostic(result, maximumLength = 600) {
+    const raw = result.stderr.trim() || result.stdout.trim();
+    const plain = stripVTControlCharacters(raw).replaceAll(/\s+/gu, " ").trim();
+    if (plain === "")
+        return `process exited with status ${result.exitCode}`;
+    if (plain.length <= maximumLength)
+        return plain;
+    return `${plain.slice(0, Math.max(0, maximumLength - 3))}...`;
+}
+export function commandFailureMessage(operation, result) {
+    return `${operation} failed: ${conciseDiagnostic(result)}`;
+}
+export function conciseError(error, maximumLength = 600) {
+    const raw = error instanceof Error ? error.message : "Unknown error";
+    const singleLine = stripVTControlCharacters(raw).replaceAll(/\s+/gu, " ").trim();
+    if (singleLine.length <= maximumLength)
+        return singleLine;
+    return `${singleLine.slice(0, Math.max(0, maximumLength - 3))}...`;
+}

package/dist/npm-cli/scripts/uninstall.js

@@ -1,10 +1,10 @@
-import { spawn } from "node:child_process";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import process from "node:process";
 import { createInterface } from "node:readline/promises";
 import { pathToFileURL } from "node:url";
 import { removePackagedDeploymentRecord, uninstallRuntime } from "./lifecycle-runtime.js";
 import { bindingProperty, configValue, deploymentListIndicatesExisting } from "./setup.js";
+import { commandFailureMessage, conciseError, runCommand as executeCommand } from "./subprocess.js";
 const CONFIG_PATH = uninstallRuntime.config;
 const STATE_PATH = uninstallRuntime.installProgress;
 const UNINSTALL_STATE_PATH = uninstallRuntime.uninstallProgress;
@@ -54,30 +54,9 @@ export function clientRemovalInstructions(connectorName = "wikimemory") {
     return `Client registrations are not removed automatically. Disconnect each configured client separately:\n\n  codex mcp logout ${connectorName}\n  codex mcp remove ${connectorName}\n\n  claude mcp logout ${connectorName}\n  claude mcp remove --scope user ${connectorName}\n\nFor Claude web or mobile, remove the custom connector from Settings > Connectors.`;
 }
 async function run(args, allowFailure = false) {
-    console.log(`\n> npx ${args.join(" ")}`);
-    const result = await new Promise((resolve, reject) => {
-        const child = spawn("npx", args, { stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-            process.stdout.write(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-            process.stderr.write(chunk);
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-        child.on("close", (code) => {
-            resolve({ stdout, stderr, exitCode: code ?? -1 });
-        });
-    });
+    const result = await executeCommand("npx", args);
     if (result.exitCode !== 0 && !allowFailure)
-        throw new Error(`npx exited with status ${result.exitCode}`);
+        throw new Error(commandFailureMessage("Cloudflare resource deletion", result));
     return result;
 }
 async function requireExactName(workerName, supplied) {
@@ -145,6 +124,7 @@ export async function runUninstall(args, runCommand = run) {
     const progress = await loadProgress(targets);
     await saveProgress(progress);
     if (!progress.workerDeleted) {
+        console.log("  Removing Worker…");
         const probe = await runCommand([
             "wrangler",
             "deployments",
@@ -172,6 +152,7 @@ export async function runUninstall(args, runCommand = run) {
         await saveProgress(progress);
     }
     if (!progress.kvDeleted) {
+        console.log("  Removing OAuth state…");
         await runCommand([
             "wrangler",
             "kv",
@@ -187,6 +168,7 @@ export async function runUninstall(args, runCommand = run) {
         await saveProgress(progress);
     }
     if (!progress.databaseDeleted) {
+        console.log("  Removing database…");
         await runCommand([
             "wrangler",
             "d1",
@@ -214,7 +196,7 @@ export async function runUninstall(args, runCommand = run) {
 const entrypoint = process.argv[1];
 if (entrypoint !== undefined && import.meta.url === pathToFileURL(entrypoint).href) {
     runUninstall(process.argv.slice(2)).catch((error) => {
-        console.error(`\nUninstall failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        console.error(`\nUninstall failed: ${conciseError(error)}`);
         process.exitCode = 1;
     });
 }

package/dist/npm-cli/scripts/upgrade.js

@@ -7,6 +7,7 @@ import { createInterface } from "node:readline/promises";
 import { z } from "zod";
 import { deploymentRecordPath, readDeploymentRecord, writeDeploymentRecord } from "./deployment-record.js";
 import { packageRoot } from "./package-root.js";
+import { commandFailureMessage, runCommand } from "./subprocess.js";
 const PACKAGE_ROOT = packageRoot();
 const DEPLOYMENT_NAME = /^[a-z0-9][a-z0-9-]{0,62}$/u;
 const MIGRATION_NAME = /^\d{4}_[a-z0-9_]+\.sql$/u;
@@ -79,6 +80,10 @@ export function compareSemanticVersions(left, right) {
     }
     return 0;
 }
+export function deploymentIsCurrent(currentVersion, manifest, pendingMigrations) {
+    return (compareSemanticVersions(currentVersion, manifest.version) === 0 &&
+        pendingMigrations.length === 0);
+}
 export function productionUpgradeConfig(record, packageRoot) {
     return `${JSON.stringify({
         $schema: join(packageRoot, "node_modules", "wrangler", "config-schema.json"),
@@ -130,28 +135,14 @@ function migrationBundle(sql, migration) {
     return `${sql.trimEnd()}\n\nINSERT INTO d1_migrations(name) VALUES ('${name}');\n`;
 }
 async function command(commandName, args) {
-    const { spawn } = await import("node:child_process");
-    return await new Promise((resolve, reject) => {
-        const child = spawn(commandName, args, { stdio: ["ignore", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-            process.stdout.write(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-            process.stderr.write(chunk);
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-        child.on("close", (code) => {
-            resolve({ stdout, stderr, exitCode: code ?? -1 });
-        });
-    });
+    return await runCommand(commandName, args);
+}
+export function upgradeSummary(record, currentVersion, targetVersion, databaseUpdates) {
+    const updates = databaseUpdates === 0 ? "none" : `${databaseUpdates} required`;
+    return `Upgrade Wikimemory “${record.workerName}” at ${record.origin}\n  Version: ${currentVersion} -> ${targetVersion}\n  Database updates: ${updates}`;
+}
+export function readySummary(version, alreadyCurrent = false) {
+    return `Wikimemory ${version} is ${alreadyCurrent ? "already " : ""}ready.\nDatabase: up to date.`;
 }
 function parsedJson(stdout) {
     return JSON.parse(stdout);
@@ -166,34 +157,64 @@ async function confirmUpgrade(summary, automatic) {
     if (answer !== "y" && answer !== "yes")
         throw new Error("Cancelled");
 }
-async function verifyRelease(origin, manifest) {
-    const health = await fetch(`${origin}/health`, { redirect: "error" });
-    const healthBody = z
-        .object({ status: z.literal("ok"), service: z.literal("wikimemory"), version: z.string() })
-        .parse(await health.json());
-    if (!health.ok || healthBody.version !== manifest.version)
-        throw new Error("Deployed Worker version verification failed");
-    const ready = await fetch(`${origin}/ready`, { redirect: "error" });
-    const readyBody = z
-        .object({
-        status: z.literal("ready"),
-        service: z.literal("wikimemory"),
-        version: z.string(),
-        schemaVersion: z.string()
-    })
-        .parse(await ready.json());
-    if (!ready.ok ||
-        readyBody.version !== manifest.version ||
-        readyBody.schemaVersion !== manifest.schemaVersion)
-        throw new Error("Deployed schema version verification failed");
-    const discovery = await fetch(`${origin}/.well-known/oauth-protected-resource/mcp`, {
-        redirect: "error"
+function sleep(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
     });
-    if (!discovery.ok)
-        throw new Error("OAuth protected-resource discovery verification failed");
-    const app = await fetch(`${origin}/app`, { redirect: "error" });
-    if (!app.ok || !(await app.text()).includes('<div id="root"></div>'))
-        throw new Error("React application verification failed");
+}
+async function responseJson(response, label) {
+    const text = await response.text();
+    if (!response.ok)
+        throw new Error(`${label} returned HTTP ${response.status}: ${text.slice(0, 300)}`);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} returned non-JSON content`);
+    }
+}
+export async function verifyRelease(origin, manifest, fetcher = fetch, sleeper = sleep, attempts = 6) {
+    let finalError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            const health = await fetcher(`${origin}/health`, { redirect: "error" });
+            const healthBody = z
+                .object({ status: z.literal("ok"), service: z.literal("wikimemory"), version: z.string() })
+                .parse(await responseJson(health, "Health endpoint"));
+            if (healthBody.version !== manifest.version) {
+                throw new Error(`Health endpoint reports version ${healthBody.version}; expected ${manifest.version}`);
+            }
+            const ready = await fetcher(`${origin}/ready`, { redirect: "error" });
+            const readyBody = z
+                .object({
+                status: z.literal("ready"),
+                service: z.literal("wikimemory"),
+                version: z.string(),
+                schemaVersion: z.string()
+            })
+                .parse(await responseJson(ready, "Readiness endpoint"));
+            if (readyBody.version !== manifest.version ||
+                readyBody.schemaVersion !== manifest.schemaVersion) {
+                throw new Error(`Readiness endpoint reports version ${readyBody.version} and schema ${readyBody.schemaVersion}; expected ${manifest.version} and ${manifest.schemaVersion}`);
+            }
+            const discovery = await fetcher(`${origin}/.well-known/oauth-protected-resource/mcp`, {
+                redirect: "error"
+            });
+            if (!discovery.ok)
+                throw new Error(`OAuth protected-resource discovery returned HTTP ${discovery.status}`);
+            const app = await fetcher(`${origin}/app`, { redirect: "error" });
+            if (!app.ok || !(await app.text()).includes('<div id="root"></div>'))
+                throw new Error("React application verification failed");
+            return;
+        }
+        catch (error) {
+            finalError = error;
+            if (attempt + 1 < attempts)
+                await sleeper(250 * 2 ** attempt);
+        }
+    }
+    const detail = finalError instanceof Error ? finalError.message : "Unknown verification failure";
+    throw new Error(`Deployed release verification failed after ${attempts} attempts: ${detail}`);
 }
 export async function runUpgrade(args) {
     const options = parseUpgradeOptions(args);
@@ -230,7 +251,7 @@ export async function runUpgrade(args) {
             command("npx", ["wrangler", "kv", "namespace", "list", ...common])
         ]);
         if ([whoami, deployments, d1, kv].some((result) => result.exitCode !== 0))
-            throw new Error("Cloudflare target preflight failed");
+            throw new Error(commandFailureMessage("Cloudflare target preflight", [whoami, deployments, d1, kv].find((result) => result.exitCode !== 0) ?? whoami));
         const whoamiBody = z
             .object({ accounts: z.array(z.object({ id: z.string() })) })
             .parse(parsedJson(whoami.stdout));
@@ -258,7 +279,7 @@ export async function runUpgrade(args) {
             "SELECT name FROM d1_migrations ORDER BY id"
         ]);
         if (listed.exitCode !== 0)
-            throw new Error("Could not read installed migrations");
+            throw new Error(commandFailureMessage("Database version check", listed));
         const query = z
             .array(z.object({ results: z.array(z.object({ name: z.string() })) }))
             .parse(parsedJson(listed.stdout));
@@ -271,7 +292,15 @@ export async function runUpgrade(args) {
             throw new Error("Current deployment health check failed");
         if (compareSemanticVersions(current, manifest.version) > 0)
             throw new Error(`Refusing to downgrade Wikimemory from ${current} to ${manifest.version}`);
-        await confirmUpgrade(`\nWikimemory upgrade\n  Account: ${record.accountId}\n  Worker: ${record.workerName}\n  D1: ${record.databaseName} (${record.databaseId})\n  KV: ${record.kvName} (${record.kvId})\n  Origin: ${record.origin}\n  Version: ${current} -> ${manifest.version}\n  Migrations: ${pending.map((item) => item.name).join(", ") || "none"}`, options.yes);
+        if (deploymentIsCurrent(current, manifest, pending)) {
+            await verifyRelease(record.origin, manifest);
+            await writeDeploymentRecord({ ...record, installedVersion: manifest.version }, recordPath);
+            console.log(`\n${readySummary(manifest.version, true)}`);
+            return;
+        }
+        await confirmUpgrade(`\n${upgradeSummary(record, current, manifest.version, pending.length)}`, options.yes);
+        if (pending.length > 0)
+            console.log("  Updating database…");
         for (const migration of pending) {
             const bundlePath = join(temporary, migration.name);
             const sql = await readFile(join(PACKAGE_ROOT, "migrations", migration.name), "utf8");
@@ -287,14 +316,16 @@ export async function runUpgrade(args) {
                 bundlePath
             ]);
             if (result.exitCode !== 0)
-                throw new Error(`Migration failed: ${migration.name}`);
+                throw new Error(commandFailureMessage("Database update", result));
         }
+        console.log("  Deploying Wikimemory…");
         const deployed = await command("npx", ["wrangler", "deploy", "--strict", ...common]);
         if (deployed.exitCode !== 0)
-            throw new Error("Worker deployment failed");
+            throw new Error(commandFailureMessage("Worker deployment", deployed));
+        console.log("  Verifying deployment…");
         await verifyRelease(record.origin, manifest);
         await writeDeploymentRecord({ ...record, installedVersion: manifest.version }, recordPath);
-        console.log(`\nWikimemory ${manifest.version} is ready. Schema: ${manifest.schemaVersion}`);
+        console.log(`\n${readySummary(manifest.version)}`);
     }
     finally {
         await rm(temporary, { recursive: true, force: true });

package/dist/npm-cli/src/version.js

@@ -1,2 +1,2 @@
-export const WIKIMEMORY_VERSION = "0.2.3";
+export const WIKIMEMORY_VERSION = "0.2.5";
 export const LATEST_SCHEMA_VERSION = "0004_credential_bound_registration_tokens.sql";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wikimemory",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Personal, passkey-protected memory for Claude, Codex, and other MCP clients",
   "license": "MIT",
   "repository": {

package/release-manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.3",
+  "version": "0.2.5",
   "schemaVersion": "0004_credential_bound_registration_tokens.sql",
   "migrations": [
     {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const WIKIMEMORY_VERSION = "0.2.3";
+export const WIKIMEMORY_VERSION = "0.2.5";
 export const LATEST_SCHEMA_VERSION = "0004_credential_bound_registration_tokens.sql";