@wirecat/cli-core 0.484.0 → 0.486.0

package/CHANGELOG.md

@@ -7,6 +7,25 @@ shape of this file.
 
 ## Unreleased
 
+## 0.486.0 — 30.10.2026
+
+### Fixed
+
+- **A messenger's `mcp revoke`, `mcp server stop` and `mcp server status` with no profile say what the profile is
+  for.** They refused with "name the profiles to serve", the words of `mcp serve`. Now: "name the profiles whose
+  browser logins to forget", "… whose server to stop", "… whose server to check". `mcp serve`, `mcp server start` and
+  `mcp config` keep "to serve". Same exit 2 and `details.profiles`.
+
+## 0.485.0 — 30.10.2026
+
+### Fixed
+
+- **A store write no longer fails with "database is locked" while another process writes steadily.** SQLite's own wait
+  for the write lock sleeps up to 100 ms between tries, so a process that commits and begins again at once was never
+  seen free, and the waiter failed after the 5 s `busy_timeout` (`mail sync` against `memo sync`). A write now tries
+  for the lock every millisecond within the same `busy_timeout`. `saveAccount` takes the lock the same way instead
+  of as a bare statement.
+
 ## 0.484.0 — 30.10.2026
 
 ### Fixed

package/dist/cli/messenger/mcp-command.d.ts

@@ -42,7 +42,7 @@ export interface ProfileSet {
 export declare const servedProfiles: (self: Command, messenger: Pick<Messenger, "app" | "resolveSettings">, { settings, env }: {
     settings: Pick<Settings, "profile" | "sources" | "profilesHere">;
     env: NodeJS.ProcessEnv;
-}, given: string | undefined, words: string) => {
+}, given: string | undefined, words: string, purpose?: string) => {
     profile: string;
 } | {
     set: ProfileSet;

package/dist/cli/messenger/mcp-command.js

@@ -23,13 +23,17 @@ const DEFAULT_PORT = MCP_HTTP_DEFAULT_PORT;
 export const ALL_PROFILES = "_all";
 /** `--profiles all`; a profile named `all` is served alone, as `<tool> all mcp serve`. */
 export const EVERY_PROFILE = "all";
+const SERVER_PURPOSE = {
+    stop: "whose server to stop",
+    status: "whose server to check",
+};
 /**
  * The profile or profiles an MCP server is for, always named (NEED-1881, WC-MCP-9): a leading profile, or
  * `--profiles` with a list or `all`. Neither, or both, is refused with the profiles on this computer. `--profiles`
  * takes the place of `<PREFIX>_PROFILE`; under `<PREFIX>_PROFILE_LOCK` it may name the locked profile only
  * (WC-ACCT-5).
  */
-export const servedProfiles = (self, messenger, { settings, env }, given, words) => {
+export const servedProfiles = (self, messenger, { settings, env }, given, words, purpose = "to serve") => {
     const { app } = messenger;
     const here = settings.profilesHere;
     const listed = `profiles here: ${here.length > 0 ? here.join(", ") : "none"}`;
@@ -42,7 +46,7 @@ export const servedProfiles = (self, messenger, { settings, env }, given, words)
     if (given === undefined) {
         if (here.length === 0)
             throw new NoProfileHere(app);
-        throw new CliError("validation_error", `name the profiles to serve: \`${app.command} <profile> ${words}\`, or \`${app.command} ${words} --profiles ` +
+        throw new CliError("validation_error", `name the profiles ${purpose}: \`${app.command} <profile> ${words}\`, or \`${app.command} ${words} --profiles ` +
             `<a,b>\` or \`--profiles all\` — ${listed}`, { profiles: here });
     }
     const names = [...new Set(given.split(",").map((one) => one.trim()))].filter(Boolean).sort();
@@ -149,7 +153,7 @@ export const mcpGroup = (host) => {
         .summary("forget every login given to a browser app")
         .description("forget every login `mcp serve --http` gave a browser app, of this profile or of the server `--profiles` names; each app must log in again")).action(async function () {
         const context = host.context(this, { needsProfile: false });
-        const served = servedProfiles(this, host, context, this.opts().profiles, "mcp revoke");
+        const served = servedProfiles(this, host, context, this.opts().profiles, "mcp revoke", "whose browser logins to forget");
         const { revokeAll } = await import("../../mcp/http/oauth.js");
         revokeAll(httpTokenFile(app, "set" in served ? served.set.key : served.profile, context.env));
         renderAnswer(this, context, itemOf("set" in served
@@ -163,7 +167,7 @@ export const mcpGroup = (host) => {
         target: (self) => {
             const context = host.context(self, { needsProfile: false });
             const { env } = context;
-            const served = servedProfiles(self, host, context, self.opts().profiles, `mcp server ${self.name()}`);
+            const served = servedProfiles(self, host, context, self.opts().profiles, `mcp server ${self.name()}`, SERVER_PURPOSE[self.name()]);
             if ("set" in served) {
                 const { set } = served;
                 return {

package/dist/store/accounts.js

@@ -11,8 +11,11 @@ export const accountAccountsOver = (context) => {
     const { accountPk, findAccountPk } = keysOver(context);
     return {
         saveAccount: async (key, { name }) => {
-            const pk = accountPk(key, name);
-            linkInbox(database, `${key.provider}:${key.account}`, pk);
+            const pk = write(database, () => {
+                const made = accountPk(key, name);
+                linkInbox(database, `${key.provider}:${key.account}`, made);
+                return made;
+            });
             linkOwnIdentities(context);
             return pk;
         },

package/dist/store/sqlite/transaction.js

@@ -1,6 +1,39 @@
 import { drainInvolvementQueue } from "./involvement-queue.js";
 import { drainMentions } from "./mention-drain.js";
 import { drainStems, stemmerCache } from "./stems.js";
+const SQLITE_BUSY = 5;
+const pause = new Int32Array(new SharedArrayBuffer(4));
+const isBusy = (error) => {
+    const { errcode, errno } = (error ?? {});
+    const code = errcode ?? errno;
+    return typeof code === "number" && (code & 0xff) === SQLITE_BUSY;
+};
+/**
+ * Takes the write lock, waiting as long as the connection's `busy_timeout`. SQLite's own wait sleeps 1 ms, then up to
+ * 100 ms between tries, so a process that commits and begins again at once is never seen free and the waiter fails
+ * with "database is locked" after the full timeout. Trying every millisecond sees the gap between two writes.
+ */
+const beginImmediate = (database) => {
+    const timeout = Number(database.prepare("PRAGMA busy_timeout").get()?.timeout ?? 0);
+    const deadline = Date.now() + timeout;
+    database.exec("PRAGMA busy_timeout = 0");
+    try {
+        for (;;) {
+            try {
+                database.exec("BEGIN IMMEDIATE");
+                return;
+            }
+            catch (error) {
+                if (!isBusy(error) || Date.now() >= deadline)
+                    throw error;
+                Atomics.wait(pause, 0, 0, 1);
+            }
+        }
+    }
+    finally {
+        database.exec(`PRAGMA busy_timeout = ${timeout}`);
+    }
+};
 const connections = new WeakMap();
 const connectionOf = (database) => {
     let connection = connections.get(database);
@@ -29,7 +62,10 @@ const transact = (database, body, drain, beforeCommit) => {
         throw new Error("a store write cannot run inside a read");
     const outer = connection.depth === 0;
     const name = `w${connection.depth + 1}`;
-    database.exec(outer ? "BEGIN IMMEDIATE" : `SAVEPOINT ${name}`);
+    if (outer)
+        beginImmediate(database);
+    else
+        database.exec(`SAVEPOINT ${name}`);
     connection.depth += 1;
     try {
         const result = body();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.484.0",
+  "version": "0.486.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",