@wirecat/cli-core 0.413.0 → 0.414.0

package/CHANGELOG.md

@@ -5,7 +5,22 @@ 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.414.0 — 25.10.2026
+
+### Added
+
+- `AppIdentity.contentLanguages`: ISO 639-1 codes of the languages a CLI's content is in. On a new store the first run pre-ticks the ones search can stem in place of English and the system's language; the person still confirms the shared choice. Unset, nothing changes.
+- Export `publicUrlOf` and `portOf` through `/mcp`, so non-messenger consumers reuse the same HTTP listener option validation as the messenger commands.
+- **A contact saved with an address joins the mail contact of that exact address.** `savePeople` takes an optional
+  `email`; the provider's contact and the mail contact become one person (`same-email`), whichever is saved first.
+  A name never joins anyone, and two identities the owner unlinked stay apart.
+- **The first screen of `tg --help`, `max --help` and `wa --help` points at `account list`.** A row under "Start here" names `<tool> account list`, which lists every profile on this computer without a profile in front, so a reader who does not know their profile names finds them. A tool without `account list` shows no row.
+
+### Fixed
+
+- Generated MCP commands accept a positional argument or its same-named flag alternative once. A single `text` input no longer emits both the argument and `--text`, which made Memo note creation fail. Positional requiredness is retained.
+- Public listener origins refuse embedded credentials before startup diagnostics can expose them.
+- **"Returns" lists the fields of commands whose output has several shapes.** A command's help and the generated `docs/commands.md` showed `message send — ; every field: …` with no fields for every output declared as a union (`message_send`, `store_info`, `chat_group_change` and others; 41 lines in tg-cli's page). The line now lists the fields of every shape, required first, as for any other output.
 
 ## 0.413.0 — 25.10.2026
 

package/dist/cli/entry.js

@@ -61,6 +61,7 @@ export const startCli = async (entry) => {
         atStart: (command) => setupAtStart({
             command: entry.app.command,
             env: io.env,
+            contentLanguages: entry.app.contentLanguages,
             path: commandPathOf(command),
             headless: headless(command),
             readOnlyLock: readOnlyLockOf(entry.app, io.env),

package/dist/cli/first-run.d.ts

@@ -25,6 +25,8 @@ export interface FirstRun {
     command: string;
     env: NodeJS.ProcessEnv;
     io: FirstRunIo;
+    /** `AppIdentity.contentLanguages`: ticked on a new store in place of English and the system's language. */
+    contentLanguages?: readonly string[] | undefined;
     /** Every question, as `setup` asks them; otherwise only those no WireCat tool asked yet. */
     all?: boolean;
     /** Where tools are looked for and how one is installed; injected by tests. */
@@ -58,6 +60,7 @@ export declare const askSetupQuestions: (run: FirstRun) => Promise<Question[]>;
 export declare const setupAtStart: (start: {
     command: string;
     env: NodeJS.ProcessEnv;
+    contentLanguages?: readonly string[] | undefined;
     path: readonly string[];
     headless: boolean;
     readOnlyLock?: string | undefined;

package/dist/cli/first-run.js

@@ -85,17 +85,19 @@ const installerHere = () => {
         return "unknown";
     }
 };
-const askLanguages = async ({ command, env, io }) => {
+const suggested = (env, contentLanguages) => {
+    const own = LANGUAGES.filter(({ code }) => contentLanguages?.includes(code));
+    const system = systemLanguage(env);
+    return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
+};
+const askLanguages = async ({ command, env, io, contentLanguages }) => {
     const store = await openStore({ env });
     let rebuild = false;
     try {
         const saved = (await store.searchIndex.stemmers()) ?? undefined;
         // A store already in use keeps the languages it was built with, so Enter changes nothing (RISK-1612).
         const inUse = saved !== undefined || (await store.accounts.accounts()).length > 0;
-        const system = systemLanguage(env);
-        const ticked = inUse
-            ? languagesOf(saved ?? DEFAULT_STEMMERS)
-            : LANGUAGES.filter(({ code }) => code === "en" || code === system).map(({ name }) => name);
+        const ticked = inUse ? languagesOf(saved ?? DEFAULT_STEMMERS) : suggested(env, contentLanguages);
         const numbers = ticked.map((name) => LANGUAGES.findIndex((one) => one.name === name) + 1);
         io.say("Languages you write and speak — search finds every form of their words, and spellings speech mangles:");
         LANGUAGES.forEach(({ name, label }, at) => {
@@ -213,6 +215,7 @@ export const setupAtStart = async (start) => {
     await askSetupQuestions({
         command: start.command,
         env: start.env,
+        contentLanguages: start.contentLanguages,
         all: start.path[0] === "setup",
         io: {
             ask: (prompt) => readSecret(prompt, { input, echo: true }),

package/dist/cli/help/command-help.js

@@ -100,16 +100,19 @@ const call = (command) => [
     ...commandPathOf(command),
     ...command.registeredArguments.map((one) => (one.required ? `<${one.name()}>` : `[${one.name()}]`)),
 ].join(" ");
+const fieldsOf = (schema) => {
+    const variants = schema.anyOf;
+    if (variants)
+        return variants.flatMap(fieldsOf);
+    const required = schema.required ?? [];
+    return [...required, ...Object.keys(schema.properties ?? {})];
+};
 const returnsOf = (command) => {
     const output = metaOf(command).output;
     const { item, coverage } = outputOf(command);
     if (!output || coverage !== "declared-entity")
         return short(command.summary() || command.description()) || "not declared";
-    const required = item.required ?? [];
-    const fields = [
-        ...required,
-        ...Object.keys(item.properties ?? {}).filter((name) => !required.includes(name)),
-    ];
+    const fields = [...new Set(fieldsOf(item))];
     const noun = (output.view ? `${output.entity} ${output.view}` : output.entity).replaceAll("_", " ");
     const more = fields.length > 8 ? `, and ${fields.length - 8} more` : "";
     const root = rootOf(command);

package/dist/cli/help/first-screen.js

@@ -64,6 +64,9 @@ const pointers = (program, cli, start, profile) => {
     ].filter((row) => row !== undefined);
     const rows = [
         ...(start ? [["Start here:", start, profile ? "(any profile name works)" : ""]] : []),
+        ...(has("account list")
+            ? [["", `${cli} account list`, "your profiles and their logged-in accounts"]]
+            : []),
         ...next.map(([command = "", does = ""], at) => [at === 0 ? "Next:" : "", command, does]),
         ...(has("skill show") ? [["For agents:", `${cli} skill show`, "rules and the discovery loop"]] : []),
     ];

package/dist/cli/program.js

@@ -267,6 +267,7 @@ const runOnce = async (argv, definition, options) => {
         await setupAtStart({
             command,
             env: commandEnv,
+            contentLanguages: definition.app.contentLanguages,
             path,
             headless,
             readOnlyLock: lock,

package/dist/http/public-url.js

@@ -14,6 +14,8 @@ export const publicUrlOf = (given, { missing, reaches }) => {
     catch {
         throw new CliError("validation_error", `--public-url is not an address: ${EXAMPLE}`);
     }
+    if (url.username || url.password)
+        throw new CliError("validation_error", "--public-url must not contain login credentials");
     const local = url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname);
     if (url.protocol !== "https:" && !local)
         throw new CliError("validation_error", `--public-url must be https — ${reaches} through it`);

package/dist/mcp/agent.js

@@ -111,7 +111,10 @@ const fieldsOf = (info, { omit = [], offline = false, stdin }) => {
         const long = longOf(option);
         if (!long || option.mcp === false)
             continue;
-        fields.push(optionField(option, long, longs.has(`--no-${long.slice(2)}`)));
+        const field = optionField(option, long, longs.has(`--no-${long.slice(2)}`));
+        // A positional and its flag alternative share one MCP input; emitting both supplies the value twice.
+        if (!fields.some((existing) => existing.name === field.name))
+            fields.push(field);
     }
     if (offline && info.effects?.remote === "read" && info.offline !== false)
         fields.push(OFFLINE);

package/dist/mcp/index.d.ts

@@ -1,3 +1,4 @@
+export { portOf, publicUrlOf } from "../http/public-url.js";
 export { type AgentAnswer, type AgentContext, type AgentProgram, type AgentTool, type CatalogueOptions, type CommandAvailability, runCommandForAgent, toolsFromCommands, } from "./agent.js";
 export { type BotServerOptions, createBotServer, type RunBotCommand } from "./bot/server.js";
 export { revokeAll } from "./http/oauth.js";

package/dist/mcp/index.js

@@ -1,4 +1,5 @@
 // Apart from the `cli` entry, so a CLI loads the MCP SDK and zod only when it serves MCP.
+export { portOf, publicUrlOf } from "../http/public-url.js";
 export { runCommandForAgent, toolsFromCommands, } from "./agent.js";
 export { createBotServer } from "./bot/server.js";
 export { revokeAll } from "./http/oauth.js";

package/dist/ports/app.d.ts

@@ -14,6 +14,11 @@ export interface AppIdentity {
     issues?: string;
     /** The language of the transcript a person reads: its day headings and the word for "you". `ru-RU` when unset. */
     locale?: string;
+    /**
+     * ISO 639-1 codes of the languages its content is mostly in (`["ru"]`). The first run pre-ticks the ones search
+     * can stem in place of English and the system's language; the person still confirms, since the choice is shared.
+     */
+    contentLanguages?: readonly string[];
     /** Error reasons and detail keys of its own — max's `max_code`, tg's `migrated_chat_id` — kept in every error it prints. */
     errors?: AppErrors;
 }

package/dist/store/people.js

@@ -12,8 +12,11 @@ export const accountPeopleOver = (context) => {
     return {
         savePeople: async (key, people) => write(database, () => {
             const accountKey = accountPk(key);
-            for (const person of people)
+            for (const person of people) {
                 identityPk(accountKey, key.provider, person.id, person.name, person);
+                if (person.email)
+                    personLinks.joinByAddress(context, { provider: key.provider, id: person.id }, person.email, key.provider);
+            }
         }),
         contacts: async (key, options) => {
             const accountKey = findAccountPk(key);

package/dist/store/sqlite/person-links.d.ts

@@ -14,6 +14,12 @@ export declare const linkIdentityToPerson: (context: StoreContext, identityPk: n
 export declare const linkIdentities: (context: StoreContext, person: IdentityRef, other: IdentityRef, options: LinkOptions) => PersonRecord;
 /** Moves every identity of `from` to `to`, as `linkIdentities` does once it has found both people. */
 export declare const mergePerson: (context: StoreContext, from: number, to: number, options: LinkOptions) => void;
+/**
+ * Joins the identity to the person of the mail contact with this exact address, making that contact when mail has
+ * not seen it yet, so whichever import comes second lands on one person. The contact is seen by no account, so it is
+ * no one's mail correspondent. An owner's unlink wins: two identities the owner separated stay apart.
+ */
+export declare const joinByAddress: (context: StoreContext, ref: IdentityRef, address: string, by: string) => void;
 /** Gives the identity a person of its own again; the ones left keep theirs. */
 export declare const unlinkIdentity: (context: StoreContext, ref: IdentityRef, options: LinkOptions) => PersonRecord;
 /** Messages that name the person: by id where the messenger said so, or by `@username` in the text. */

package/dist/store/sqlite/person-links.js

@@ -1,5 +1,6 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, isNull, sql } from "./drizzle/core.js";
+import { identityOf } from "./identities.js";
 import { resolvePersonLinks } from "./person-resolution.js";
 import { accountIdentities, accounts, chats, identities, identityLinkEvents, identityLinks, messages, persons, } from "./schema.js";
 import { hitsWhere } from "./search.js";
@@ -135,6 +136,32 @@ export const mergePerson = (context, from, to, options) => {
     for (const { identityPk } of together)
         move(context, identityPk, from, to, options);
 };
+/** The owner once moved one of the two identities away from a person the other belonged to. */
+const separatedByOwner = ({ database }, one, other) => database
+    .prepare(`SELECT 1 FROM identity_link_events moved
+       JOIN identity_link_events held ON held.to_person_id = moved.from_person_id
+       WHERE moved.author = 'owner' AND ((moved.identity_id = ? AND held.identity_id = ?)
+         OR (moved.identity_id = ? AND held.identity_id = ?))
+       LIMIT 1`)
+    .get(one, other, other, one) !== undefined;
+/**
+ * Joins the identity to the person of the mail contact with this exact address, making that contact when mail has
+ * not seen it yet, so whichever import comes second lands on one person. The contact is seen by no account, so it is
+ * no one's mail correspondent. An owner's unlink wins: two identities the owner separated stay apart.
+ */
+export const joinByAddress = (context, ref, address, by) => {
+    const key = address.trim().toLowerCase();
+    if (!/^[^\s@]+@[^\s@]+$/.test(key) || ref.provider === "email")
+        return;
+    const found = required(context, ref);
+    if (!identityRow(context, { provider: "email", id: key }))
+        identityOf(context, "email", key, null);
+    const contact = required(context, { provider: "email", id: key });
+    if (contact.personPk === found.personPk || separatedByOwner(context, found.pk, contact.pk))
+        return;
+    mergePerson(context, found.personPk, contact.personPk, { method: "same-email", by });
+    resolvePersonLinks(context.database, recordOf(context, contact.personPk).identities.flatMap(({ name, username }) => [name, username]));
+};
 /** Gives the identity a person of its own again; the ones left keep theirs. */
 export const unlinkIdentity = (context, ref, options) => {
     const found = required(context, ref);

package/dist/store/types.d.ts

@@ -32,6 +32,8 @@ export interface PersonFacts {
     username?: string | null;
     isBot?: boolean | null;
     description?: string | null;
+    /** An address the provider shows for them: they become one person with the mail contact of that exact address. */
+    email?: string | null;
 }
 /** One identity in one messenger, by the messenger's own id. `provider` is any string: `email` is one. */
 export interface IdentityRef {

package/package.json

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