@wirecat/cli-core 0.464.0 → 0.466.0

package/CHANGELOG.md

@@ -5,7 +5,35 @@ Notable changes to `@wirecat/cli-core` (`@wirecat/cli-messaging` up to 0.261.0,
 minor version may break callers, and says how under "Changed — may break callers". `pnpm docs:check` checks the
 shape of this file.
 
-## Unreleased
+## 0.466.0 — 27.10.2026
+
+### Changed — may break callers
+
+- **`account list` says whether each profile is signed in on this computer.** The `account_profile` entity gains an
+  optional `signed_in`, set when the messenger sets `Messenger.profileState`; a caller that checks items against an
+  older, strict copy of it refuses the new field.
+
+### Fixed
+
+- **`<cli> mcp serve` with no profile marks the profiles that are not signed in.** A messenger sets the new optional
+  `Messenger.profileState(profile, env)` (`signed-in`, `signed-out` or `bot`), read from its own files without
+  connecting. The `profile` field keeps its `enum` and gains `oneOf` entries with a `title` per profile
+  (`default — not signed in`), as MCP's titled enums, and its description lists who is signed in. Bot profiles are left
+  out: they have their own server. A call for a profile that is not signed in is refused with how to sign it in
+  (`<cli> <profile> setup`, or WireCat Desktop) and starts nothing. Unset, every profile counts as signed in, as before.
+- **The "no profile named" error marks the listed profiles that are not signed in** (`beta (not signed in)`), when the
+  messenger sets `profileState`.
+- **The MCP login page says why a code that just worked is now wrong.** Each login code works once; after an app
+  logs in, the server shows a new one. The wrong-code message now says so and points to WireCat Desktop and
+  `<cli> mcp server status`, where the new code is.
+
+## 0.465.0 — 27.10.2026
+
+### Changed — may break callers
+
+- **The calendar `sync` starts over with `--rescan`, not `--full`**, the start-over flag WC-LIFE-13 names and drive's
+  `sync --rescan` uses. `--full` is the shared program's output flag; `sync --full` is now refused with a message
+  that names `--rescan`, rather than quietly reading only the changes.
 
 ## 0.464.0 — 27.10.2026
 

package/dist/background/relay.js

@@ -75,6 +75,7 @@ export const listenRelay = async (path, run) => {
     // The caller holds the serve lock, so a socket left here belongs to a serve that is gone.
     rmSync(path, { force: true });
     const open = new Set();
+    const running = new Set();
     const server = createServer((socket) => {
         open.add(socket);
         const stop = new AbortController();
@@ -111,7 +112,9 @@ export const listenRelay = async (path, run) => {
                 stdin.isTTY = parsed.output.stdinTty;
                 if (parsed.output.stdinTty)
                     stdin.end();
-                void serve(socket, parsed.output, stdin, stop.signal, run);
+                const job = serve(socket, parsed.output, stdin, stop.signal, run);
+                running.add(job);
+                void job.then(() => running.delete(job), () => running.delete(job));
                 return;
             }
             if (typeof message.stdin === "string" && !stdin.writableEnded)
@@ -133,6 +136,7 @@ export const listenRelay = async (path, run) => {
             for (const socket of open)
                 socket.destroy();
             await new Promise((resolve) => server.close(() => resolve()));
+            await Promise.allSettled(running);
             rmSync(path, { force: true });
         },
     };

package/dist/calendar/cli/index.js

@@ -122,21 +122,22 @@ const addCalendarCommandsDefinition = (program, deps) => {
         offline: false,
         cooperative: true,
         partial: true,
-    }).description("bring the synced calendars up to date: what changed since the last sync, or everything with --full; a run " +
-        "stops before its deadline or --max-pages and the next one goes on from there"), "sync", "sync --full --embed", "sync --timeout 2m"))
-        .option("--full", "list every synced calendar's window again, dropping a round in progress")
+    }).description("bring the synced calendars up to date: what changed since the last sync, or everything with --rescan; a run " +
+        "stops before its deadline or --max-pages and the next one goes on from there"), "sync", "sync --rescan --embed", "sync --timeout 2m"))
+        .option("--rescan", "list every synced calendar's window again, dropping a round in progress")
         .option("--max-pages <pages>", "at most this many requests to the provider in this run; as many as fit the deadline if not given", integer)
         .option("--embed", "also index new events for meaning search, with a model already downloaded")
         .action(async (opts, command) => {
-        // The shared program has a global --full of its own, which claims the flag before this command sees it.
-        const full = command.optsWithGlobals().full === true;
+        // --full is the shared program's output flag; it used to start the round over here, and silently would not now.
+        if (command.optsWithGlobals().full)
+            throw new CliError("validation_error", "sync starts over with --rescan; --full only widens output");
         const { signal } = environmentOf(command);
         const report = await syncCalendars(source(), deps.store, {
             accountId: deps.accountId,
             now: now(),
             budget: runBudgetOf(command, opts.maxPages),
             ...(signal ? { signal } : {}),
-            ...(full ? { full: true } : {}),
+            ...(opts.rescan ? { full: true } : {}),
             ...(deps.expand ? { expand: deps.expand } : {}),
         });
         if (opts.embed && !deps.embed)
@@ -144,7 +145,7 @@ const addCalendarCommandsDefinition = (program, deps) => {
         // A run its budget stopped has no time left for the model; the run that finishes the round embeds.
         const embeddings = opts.embed && !report.stopped ? await deps.embed?.(EMBED_MAX) : undefined;
         const timeout = command.optsWithGlobals().timeout;
-        // The same command again, never --full: that would drop the round this run leaves in progress. A run that moved
+        // The same command again, never --rescan: that would drop the round this run leaves in progress. A run that moved
         // nothing on would only repeat itself, so it gets no step an agent may run unasked.
         const stuck = report.state === "partial" && report.progress.steps === 0 && !report.synced.some((one) => one.error);
         const next = report.state === "partial" && !stuck && !report.synced.some((one) => one.error !== undefined)

package/dist/cli/index.d.ts

@@ -88,7 +88,7 @@ export { type MeetingSeriesInventoryReader, readMeetingSeriesInventory } from ".
 export { accountFileFor, profilesHere, rememberAccount } from "./messenger/accounts.js";
 export { terminalAsker } from "./messenger/ask.js";
 export type { CompletionOptions } from "./messenger/complete-command.js";
-export { type ConnectOptions, connectFor, type Messenger, type MessengerContext, messengerContext, type ReadConnection, type StoredMessages, } from "./messenger/context.js";
+export { type ConnectOptions, connectFor, type Messenger, type MessengerContext, messengerContext, type ProfileState, type ReadConnection, type StoredMessages, } from "./messenger/context.js";
 export { COMMAND_NEEDS } from "./messenger/lacks.js";
 export { httpTokenFile, type McpEnvironment, serverEntry } from "./messenger/mcp-command.js";
 export { type MessageItem, messageItem, type ReadMessage } from "./messenger/message-items.js";

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

@@ -45,6 +45,9 @@ export const accountCommand = (messenger) => {
                     current: profile === current,
                     account: key?.account ?? null,
                     name: key && store ? await store.accounts.accountName(key) : null,
+                    ...(messenger.profileState
+                        ? { signed_in: messenger.profileState(profile, context.env) !== "signed-out" }
+                        : {}),
                 });
             }
             renderAnswer(this, context, wholeList("account list", items));

package/dist/cli/messenger/context.d.ts

@@ -49,6 +49,7 @@ export interface LazyStore {
 }
 export declare const lazyStore: (env: NodeJS.ProcessEnv, command: string, version?: string) => LazyStore;
 export declare const storedMessages: (provider: Provider, store: () => Promise<MessageStore>, account: () => Id | null | undefined) => StoredMessages;
+export type ProfileState = "signed-in" | "signed-out" | "bot";
 /** What one messenger CLI hands the shared commands. Everything else about it stays in its own code. */
 export interface Messenger extends ServiceMessenger {
     /**
@@ -65,6 +66,12 @@ export interface Messenger extends ServiceMessenger {
      * Called inside `--timeout`; the context tracks and closes what it returns.
      */
     connect: (command: Command, context: BaseContext, options?: ConnectOptions) => Promise<MessengerAdapter>;
+    /**
+     * A profile's state, read from the messenger's own files without connecting: `signed-in` has a session, `signed-out`
+     * has none yet, `bot` speaks for a bot. `<tool> mcp` with no profile offers the personal ones and marks those not
+     * signed in; `account list` and the profile errors say so too. Unset: every profile counts as signed in.
+     */
+    profileState?: (profile: string, env: NodeJS.ProcessEnv) => ProfileState;
     /** The help for a `<chat>` argument, in this messenger's words. */
     chatArgument: string;
     /** The group settings this messenger has, as `chats update` offers them; every one when unset. */
@@ -262,6 +269,8 @@ export declare const connectedFor: (command: Command, messenger: Pick<Messenger,
     adapter: MessengerAdapter;
     close: () => Promise<void>;
 }>;
+/** `default (not signed in)`: a profile as an error lists it among the choices. */
+export declare const markedProfile: (messenger: Messenger, profile: string, env: NodeJS.ProcessEnv) => string;
 /**
  * A write to the local store alone. `deny` already stopped the command (`messengerContext`); `readonly`
  * stops this write too. There is no question to put to the owner here, so `ask` refuses rather than

package/dist/cli/messenger/context.js

@@ -288,9 +288,11 @@ export const connectedFor = async (command, messenger, base, options) => {
         }),
     };
 };
-const unrecorded = (command, messenger, profile, { offline, profilesHere }) => {
+/** `default (not signed in)`: a profile as an error lists it among the choices. */
+export const markedProfile = (messenger, profile, env) => messenger.profileState?.(profile, env) === "signed-out" ? `${profile} (not signed in)` : profile;
+const unrecorded = (command, messenger, profile, { offline, profilesHere }, env) => {
     if (!profilesHere.includes(profile)) {
-        return new CliError("not_found", `no profile named "${profile}" — profiles here: ${profilesHere.length > 0 ? profilesHere.join(", ") : "none"}`, { profiles: profilesHere });
+        return new CliError("not_found", `no profile named "${profile}" — profiles here: ${profilesHere.length > 0 ? profilesHere.map((one) => markedProfile(messenger, one, env)).join(", ") : "none"}`, { profiles: profilesHere });
     }
     const words = `${messenger.app.command} ${asFirstWord(profile)}`;
     const setup = rootOf(command).commands.some((one) => one.name() === "setup") ? `\`${words}setup\`` : undefined;
@@ -361,7 +363,7 @@ export const messengerContext = (command, messenger, resolving = {}) => {
     const accountFor = () => {
         const account = messenger.accountOf?.(command) ?? recalledAccount(app, provider, profile, base.env);
         if (!account)
-            throw unrecorded(command, messenger, profile, base.settings);
+            throw unrecorded(command, messenger, profile, base.settings, base.env);
         return account;
     };
     const guard = messenger.guard?.(command, base.settings, warn) ??

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

@@ -222,7 +222,11 @@ const serveEveryProfile = async (self, context, messenger, flags) => {
     const { app } = messenger;
     const { env } = context;
     const tokenFile = httpTokenFile(app, ALL_PROFILES, env);
-    const profiles = () => messenger.resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true }).profilesHere;
+    const state = (profile) => messenger.profileState?.(profile, env) ?? "signed-in";
+    // Read again for each session, so a profile set up while the server runs appears. A bot has its own server.
+    const profiles = () => messenger
+        .resolveSettings(self.optsWithGlobals(), { env, needsProfile: false, readOnly: true })
+        .profilesHere.filter((profile) => state(profile) !== "bot");
     if (profiles().length === 0)
         throw new CliError("configuration_error", `no ${app.command} profile on this computer yet — set one up, then run \`${app.command} mcp serve\` again`);
     const given = environmentOf(self).mcp ?? {};
@@ -235,6 +239,9 @@ const serveEveryProfile = async (self, context, messenger, flags) => {
         version: app.version,
         name: messenger.name ?? app.command,
         profiles,
+        signedIn: (profile) => state(profile) === "signed-in",
+        signIn: (profile) => `profile ${profile} is not signed in — run \`${app.command} ${profile} setup\`, or sign in from WireCat Desktop, ` +
+            "then try again. If the owner did not choose this profile, ask which one.",
         child: (profile) => ({ command: execPath, args: [scriptPath, profile, "mcp", "serve", ...tightened], env }),
         instructions: instructions({
             command: app.command,

package/dist/cli/messenger/serve-relay.d.ts

@@ -39,6 +39,7 @@ export declare const serveRelay: (command: Command, messenger: Messenger) => {
         connection?: "exclusive";
         pace?: import("../../sends/pace.js").PaceRate;
         resolveSettings: (flags: import("../settings.js").GlobalFlags, options?: import("../settings.js").ResolveOptions) => import("../settings.js").Settings;
+        profileState?: (profile: string, env: NodeJS.ProcessEnv) => import("./context.js").ProfileState;
         chatArgument: string;
         groupSettings?: readonly import("../../domain/models.js").GroupSettingKey[];
         pollQuiz?: boolean;

package/dist/entities/account-profile.d.ts

@@ -4,4 +4,6 @@ export declare const accountProfile: v.StrictObjectSchema<{
     readonly current: v.BooleanSchema<undefined>;
     readonly account: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
     readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** False for a profile with no session on this computer; absent when the messenger does not say. */
+    readonly signed_in: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>;

package/dist/entities/account-profile.js

@@ -5,4 +5,6 @@ export const accountProfile = v.strictObject({
     current: v.boolean(),
     account: v.nullable(id),
     name: v.nullable(text),
+    /** False for a profile with no session on this computer; absent when the messenger does not say. */
+    signed_in: v.optional(v.boolean()),
 });

package/dist/entities/index.d.ts

@@ -4177,6 +4177,7 @@ export declare const ENTITIES: {
         readonly current: v.BooleanSchema<undefined>;
         readonly account: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
         readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly signed_in: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>;
     readonly organization: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;

package/dist/mcp/all-profiles.d.ts

@@ -16,14 +16,22 @@ export interface AllProfilesOptions {
     name: string;
     /** Read again for each new session, so a profile set up while serving over HTTP shows up. */
     profiles: () => readonly string[];
+    /** Whether a profile has a session now; unset, every one does. A call for one without is refused with `signIn`. */
+    signedIn?: (profile: string) => boolean;
+    /** How to sign a profile in, for the refusal of a call it cannot serve yet. */
+    signIn?: (profile: string) => string;
     child: (profile: string) => ChildSpec;
     instructions: string;
     idleMs?: number;
     /** A child's stderr, line by line; never this process's stdout, which carries the protocol. */
     note?: (line: string) => void;
 }
-/** The child's tool with the one field that picks the profile, required and without a default. */
-export declare const withProfile: (tool: Tool, profiles: readonly string[], name: string) => Tool;
+/**
+ * The child's tool with the one field that picks the profile, required and without a default. Each profile carries
+ * its state as the title an app shows in its menu (`oneOf` with `const` and `title`, as MCP's titled enums), and the
+ * description repeats it for an app that shows only the description.
+ */
+export declare const withProfile: (tool: Tool, profiles: readonly string[], name: string, signedIn?: (profile: string) => boolean) => Tool;
 /**
  * **One server for every profile of a tool** (TASK-26): `<tool> mcp` shows the tools `<tool> <profile> mcp` shows,
  * each with a required `profile`, and runs a call in that profile's own server, started as a child the first time

package/dist/mcp/all-profiles.js

@@ -138,9 +138,17 @@ const pool = (options) => {
     };
     return { use, close };
 };
-/** The child's tool with the one field that picks the profile, required and without a default. */
-export const withProfile = (tool, profiles, name) => {
+/**
+ * The child's tool with the one field that picks the profile, required and without a default. Each profile carries
+ * its state as the title an app shows in its menu (`oneOf` with `const` and `title`, as MCP's titled enums), and the
+ * description repeats it for an app that shows only the description.
+ */
+export const withProfile = (tool, profiles, name, signedIn = () => true) => {
     const schema = tool.inputSchema;
+    const out = profiles.filter((profile) => !signedIn(profile));
+    const states = out.length === 0
+        ? ""
+        : ` Signed in: ${profiles.filter(signedIn).join(", ") || "none"} · Not signed in: ${out.join(", ")}.`;
     return {
         ...tool,
         inputSchema: {
@@ -149,7 +157,11 @@ export const withProfile = (tool, profiles, name) => {
                 profile: {
                     type: "string",
                     enum: [...profiles],
-                    description: `Which ${name} account, by its profile. If the owner did not name one, ask which — never guess.`,
+                    oneOf: profiles.map((profile) => ({
+                        const: profile,
+                        title: signedIn(profile) ? profile : `${profile} — not signed in`,
+                    })),
+                    description: `Which ${name} account, by its profile. If the owner did not name one, ask which — never guess.${states}`,
                 },
                 ...schema.properties,
             },
@@ -174,24 +186,29 @@ export const allProfilesServer = (options) => {
     // list comes from whichever answers first and is kept.
     const tools = (profiles) => {
         listed ??= children
-            .use(profiles[0], (child) => child.request("tools/list", {}))
+            .use(profiles.find(signedIn) ?? profiles[0], (child) => child.request("tools/list", {}))
             .then((answer) => (answer.tools ?? []));
         listed.catch(() => {
             listed = undefined;
         });
         return listed;
     };
+    const signedIn = (profile) => options.signedIn?.(profile) ?? true;
     const build = () => {
         const profiles = [...options.profiles()].sort();
         const server = new McpServer({ name: options.command, version: options.version }, { capabilities: { tools: {} }, instructions: options.instructions });
         server.server.setRequestHandler("tools/list", async () => ({
-            tools: profiles.length === 0 ? [] : (await tools(profiles)).map((one) => withProfile(one, profiles, options.name)),
+            tools: profiles.length === 0
+                ? []
+                : (await tools(profiles)).map((one) => withProfile(one, profiles, options.name, signedIn)),
         }));
         server.server.setRequestHandler("tools/call", async (request) => {
             const { name, arguments: given = {}, _meta } = request.params;
             const { profile, ...rest } = given;
             if (typeof profile !== "string" || !profiles.includes(profile))
                 return refusal(`${name} needs "profile", one of: ${profiles.join(", ")}. If the owner did not say which account, ask.`);
+            if (!signedIn(profile))
+                return refusal(options.signIn?.(profile) ?? `profile ${profile} is not signed in.`);
             try {
                 return (await children.use(profile, (child) => child.request("tools/call", { name, arguments: rest, ...(_meta ? { _meta } : {}) })));
             }

package/dist/mcp/http/oauth.js

@@ -201,7 +201,7 @@ export const ownerLogin = ({ issuer, resource, file, appName, onCode, now = () =
                 retryAt = now() + WRONG_CODE_WAIT_MS;
                 return throttled();
             }
-            return page(params, client, `Wrong code. ${WRONG_TRIES - wrong} tries left.`);
+            return page(params, client, `Wrong code. Each code works for one login: after an app logs in, a new one appears in WireCat Desktop and in "${appName} mcp server status". ${WRONG_TRIES - wrong} tries left.`);
         }
         wrong = 0;
         freshCode();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.464.0",
+  "version": "0.466.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",