wikimemory 0.2.4 → 0.2.6

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

@@ -3,8 +3,9 @@ import { mkdir } from "node:fs/promises";
 import process from "node:process";
 import { WIKIMEMORY_VERSION } from "../src/version.js";
 import { deploymentArguments, installArguments } from "./cli-options.js";
-import { deploymentPaths } from "./deployment-record.js";
+import { deploymentPaths, requireInstalledDeployment } 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.`;
@@ -33,6 +34,18 @@ async function main() {
     }
     const parsed = deploymentArguments(args);
     const paths = deploymentPaths(parsed.deployment);
+    const requiresInstalledDeployment = command === "recover" ||
+        command === "status" ||
+        command === "passkeys" ||
+        command === "connect" ||
+        command === "uninstall" ||
+        (command === "upgrade" && !parsed.remaining.includes("--record"));
+    if (requiresInstalledDeployment) {
+        const requirement = command === "recover" || command === "passkeys" || command === "uninstall"
+            ? "config"
+            : "record";
+        await requireInstalledDeployment(parsed.deployment, requirement);
+    }
     if (command === "install" || command === "recover") {
         await mkdir(paths.directory, { recursive: true, mode: 0o700 });
         process.env["WIKIMEMORY_PACKAGE_ROOT"] = root;
@@ -74,6 +87,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/deployment-record.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { access, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { z } from "zod";
@@ -44,6 +44,43 @@ export function deploymentPaths(deployment = "wikimemory") {
         passkeyClient: join(directory, "passkey-client.json")
     };
 }
+export async function requireInstalledDeployment(deployment, requirement = "record") {
+    const requestedPaths = deploymentPaths(deployment);
+    const requested = requirement === "record" ? requestedPaths.record : requestedPaths.config;
+    try {
+        await access(requested);
+        return;
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    const configRoot = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+    const deploymentsRoot = join(configRoot, "wikimemory", "deployments");
+    let installed = [];
+    try {
+        const entries = (await readdir(deploymentsRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && DEPLOYMENT_NAME.test(entry.name));
+        const candidates = await Promise.all(entries.map(async (entry) => {
+            try {
+                await access(join(deploymentsRoot, entry.name, "deployment.json"));
+                return entry.name;
+            }
+            catch (error) {
+                if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                    return null;
+                throw error;
+            }
+        }));
+        installed = candidates.filter((name) => name !== null).sort();
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            throw error;
+    }
+    if (installed.length === 0)
+        throw new Error(`No deployment named “${deployment}”. Run wikimemory install first.`);
+    throw new Error(`No deployment named “${deployment}”. Installed: ${installed.join(", ")}. Use --deployment NAME.`);
+}
 export function deploymentRecordFromConfig(configText, installedVersion, kvName) {
     const config = PRODUCTION_CONFIG_SCHEMA.parse(JSON.parse(configText));
     const database = config.d1_databases.at(0);

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

@@ -0,0 +1,4 @@
+export const DEPLOYMENT_VERIFY_ATTEMPTS = 25;
+export function deploymentVerifyDelay(completedAttempt) {
+    return Math.min(1000 * 2 ** completedAttempt, 5000);
+}

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";
@@ -10,7 +9,10 @@ import { pathToFileURL } from "node:url";
 import { z } from "zod";
 import { WIKIMEMORY_VERSION } from "../src/version.js";
 import { deploymentRecordFromConfig, writeDeploymentRecord } from "./deployment-record.js";
+import { DEPLOYMENT_VERIFY_ATTEMPTS, deploymentVerifyDelay } from "./deployment-wait.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 +57,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 +138,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({
@@ -354,7 +320,7 @@ function bootstrapSecret() {
     const hash = createHash("sha256").update(raw, "utf8").digest("hex");
     return { raw, hash };
 }
-export async function verifyEndpoint(origin, path, expectedStatus, fetcher = fetch, sleeper = sleep, attempts = 6) {
+export async function verifyEndpoint(origin, path, expectedStatus, fetcher = fetch, sleeper = sleep, attempts = DEPLOYMENT_VERIFY_ATTEMPTS) {
     let finalDetail = "no response";
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         try {
@@ -379,7 +345,7 @@ export async function verifyEndpoint(origin, path, expectedStatus, fetcher = fet
             finalDetail = error instanceof Error ? error.message : "Unknown request failure";
         }
         if (attempt + 1 < attempts)
-            await sleeper(250 * 2 ** attempt);
+            await sleeper(deploymentVerifyDelay(attempt));
     }
     throw new Error(`Deployment ${path} check failed after ${attempts} attempts: ${finalDetail}`);
 }
@@ -504,7 +470,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 +567,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

@@ -6,7 +6,9 @@ import process from "node:process";
 import { createInterface } from "node:readline/promises";
 import { z } from "zod";
 import { deploymentRecordPath, readDeploymentRecord, writeDeploymentRecord } from "./deployment-record.js";
+import { DEPLOYMENT_VERIFY_ATTEMPTS, deploymentVerifyDelay } from "./deployment-wait.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;
@@ -134,28 +136,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);
@@ -186,7 +174,7 @@ async function responseJson(response, label) {
         throw new Error(`${label} returned non-JSON content`);
     }
 }
-export async function verifyRelease(origin, manifest, fetcher = fetch, sleeper = sleep, attempts = 6) {
+export async function verifyRelease(origin, manifest, fetcher = fetch, sleeper = sleep, attempts = DEPLOYMENT_VERIFY_ATTEMPTS) {
     let finalError;
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         try {
@@ -223,7 +211,7 @@ export async function verifyRelease(origin, manifest, fetcher = fetch, sleeper =
         catch (error) {
             finalError = error;
             if (attempt + 1 < attempts)
-                await sleeper(250 * 2 ** attempt);
+                await sleeper(deploymentVerifyDelay(attempt));
         }
     }
     const detail = finalError instanceof Error ? finalError.message : "Unknown verification failure";
@@ -264,7 +252,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));
@@ -292,7 +280,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));
@@ -308,10 +296,12 @@ export async function runUpgrade(args) {
         if (deploymentIsCurrent(current, manifest, pending)) {
             await verifyRelease(record.origin, manifest);
             await writeDeploymentRecord({ ...record, installedVersion: manifest.version }, recordPath);
-            console.log(`\nWikimemory ${manifest.version} is already ready. Reconciled the local deployment record without redeploying.`);
+            console.log(`\n${readySummary(manifest.version, true)}`);
             return;
         }
-        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);
+        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");
@@ -327,14 +317,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.4";
+export const WIKIMEMORY_VERSION = "0.2.6";
 export const LATEST_SCHEMA_VERSION = "0004_credential_bound_registration_tokens.sql";