@wirecat/cli-core 0.550.0 → 0.552.0

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

@@ -2,7 +2,9 @@ import { CliError } from "@wirecat/cli-base";
 import { annotate } from "@wirecat/cli-base/commands";
 import { Command } from "commander";
 import { holdLock, lockPath, releaseLock, takeLock } from "../../background/lock.js";
+import { parseDuration } from "../../domain/duration.js";
 import { failureKey } from "../../errors/failures.js";
+import { capability } from "../../ports/messenger.js";
 import { senderFacts } from "../../replies/dry-run.js";
 import { replyRenderer } from "../../replies/rendering.js";
 import { audienceWarnings, readReplies, repliesPathFor } from "../../replies/rules.js";
@@ -10,14 +12,17 @@ import { NO_RULES, replyTo } from "../../replies/serve.js";
 import { repliesStatePathFor } from "../../replies/state.js";
 import { levelFor } from "../../sends/permissions.js";
 import { newSendId } from "../../sends/send-id.js";
+import { FETCHING } from "../../services/archive.js";
 import { onlineDeps } from "../../services/deps.js";
 import { servicesFor } from "../../services/index.js";
+import { patiently } from "../../services/patience.js";
 import { applyTaskRulesOnArrival, openRequestTask } from "../../services/task-rules.js";
 import { environmentOf } from "../context.js";
 import { REMOTE_WRITE } from "../effects.js";
 import { itemOf, renderAnswer } from "../envelope.js";
 import { recalledAccount } from "./accounts.js";
 import { messengerContext } from "./context.js";
+import { START_SYNC_PER_CHAT, startSync } from "./serve-catch-up.js";
 import { memberFetches } from "./serve-members.js";
 import { noticeFor, recordDiagnostics } from "./serve-notice.js";
 import { serveRelay } from "./serve-relay.js";
@@ -75,7 +80,7 @@ export const serveCommand = (messenger) => {
         const counts = {};
         const rules = replying(context, messenger, Date.parse(startedAt));
         const tasks = tasking(context, warn);
-        const { handled } = environmentOf(this);
+        const { handled, startSyncDelayMs } = environmentOf(this);
         const count = (event) => {
             counts[event.event] = (counts[event.event] ?? 0) + 1;
             if (event.event === "message") {
@@ -99,6 +104,50 @@ export const serveCommand = (messenger) => {
             }).chats.fetchMembers(chatId, {}),
             warn,
         });
+        const fetching = messenger.fetching ?? FETCHING;
+        const catchingUp = startSync({
+            chats: async (stop) => {
+                const list = capability(connection, "chats", "list its chats");
+                const all = [];
+                for (let offset = 0;;) {
+                    const page = await patiently(() => list({ offset, limit: 100 }), context.renderer.note, stop);
+                    for (const chat of page.items)
+                        all.push(chat);
+                    offset += page.items.length;
+                    if (!page.hasMore || page.items.length === 0)
+                        return all;
+                }
+            },
+            newestHeld: (chatId) => context.withStore(async (store, account) => {
+                // What this serve stored itself would hide the gap before it.
+                const [newest] = await store.messages.messagesWindow(account, chatId, {
+                    at: startedAt,
+                    before: 1,
+                    after: 0,
+                });
+                return newest ? Date.parse(newest.timestamp) : undefined;
+            }, { name: "serve catch-up" }),
+            fetch: (chatId, sinceMs, stop) => context.withStore((store, account) => servicesFor({
+                ...onlineDeps(messenger, connection, context.guard, {
+                    profile: context.profile,
+                    env: context.env,
+                }),
+                store: async () => store,
+                account: async () => account,
+            }).archive.fetch(chatId, {
+                limit: START_SYNC_PER_CHAT,
+                pageSize: fetching.page,
+                pauseMs: parseDuration(fetching.pause, "pause"),
+                sinceMs,
+                catchUp: false,
+                note: context.renderer.note,
+                stop,
+                onPage: () => { },
+            }), { name: "serve catch-up" }),
+            note,
+            warn,
+            ...(startSyncDelayMs === undefined ? {} : { delayMs: startSyncDelayMs }),
+        });
         const stems = stemFills({
             withStore: (work) => context.withStore((store) => work(store), { name: "serve stems" }),
             warn,
@@ -113,6 +162,8 @@ export const serveCommand = (messenger) => {
                     rules.connected(open);
                     members.start();
                     stems.start();
+                    if (messenger.history !== "store" && typeof open.chats === "function")
+                        catchingUp.start();
                 },
             });
         }
@@ -120,6 +171,7 @@ export const serveCommand = (messenger) => {
             await relaying;
             await relay?.close();
             rules.stop();
+            await catchingUp.stop();
             await members.stop();
             await stems.stop();
             await rules.settled();
@@ -135,6 +187,7 @@ export const serveCommand = (messenger) => {
             ...rules.summary(),
             ...(members.summary().fetched + members.summary().failed > 0 ? { members: members.summary() } : {}),
             ...(stems.summary().stemmed > 0 ? { stems: stems.summary() } : {}),
+            ...(catchingUp.summary() ? { caught_up: catchingUp.summary() } : {}),
             ...tasks.summary(),
         }));
     });

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

@@ -35,8 +35,9 @@ export interface ServerOptions {
 /**
  * `serve` in the background: `start`, `stop`, `restart`, `status`, `logs`. Without a unit, `start`
  * runs `serve` as a process of its own; with one — `install`, a systemd user unit or a launchd
- * agent — it goes through systemd or launchd. **Nothing starts until `start` is typed** (NEED-9):
- * `install` only writes the file. What the server does stays each CLI's; `options.process` says how
- * to find, start and stop it.
+ * agent — it goes through systemd or launchd. **Nothing starts now until `start` is typed** (NEED-9):
+ * `install` writes the file and enables it, so it starts with every session from the next login (or boot,
+ * under linger) until `uninstall`. What the server does stays each CLI's; `options.process` says how to find,
+ * start and stop it.
  */
 export declare const serverCommand: (messenger: Messenger, options?: ServerOptions) => Command;

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

@@ -54,9 +54,10 @@ const lockProcess = (app, marker, serveArgv) => (context, system, logPath) => ({
 /**
  * `serve` in the background: `start`, `stop`, `restart`, `status`, `logs`. Without a unit, `start`
  * runs `serve` as a process of its own; with one — `install`, a systemd user unit or a launchd
- * agent — it goes through systemd or launchd. **Nothing starts until `start` is typed** (NEED-9):
- * `install` only writes the file. What the server does stays each CLI's; `options.process` says how
- * to find, start and stop it.
+ * agent — it goes through systemd or launchd. **Nothing starts now until `start` is typed** (NEED-9):
+ * `install` writes the file and enables it, so it starts with every session from the next login (or boot,
+ * under linger) until `uninstall`. What the server does stays each CLI's; `options.process` says how to find,
+ * start and stop it.
  */
 export const serverCommand = (messenger, options = {}) => {
     const { app } = messenger;
@@ -226,8 +227,11 @@ export const serverCommand = (messenger, options = {}) => {
             : undefined;
         const gaveUpReason = gaveUp === undefined ? undefined : Object.entries(EXIT_CODES).find(([, code]) => code === gaveUp)?.[0];
         const flood = new FloodMemory(floodPathFor(app, unit.profile, context.env)).read();
+        const startsAtLogin = isInstalled && state.enabled === true;
         const unitLine = isInstalled
-            ? `Unit: ${tilde(unit.path, context.env)} — ${state.detail ?? (state.active ? "active" : "inactive")}.`
+            ? `Unit: ${tilde(unit.path, context.env)} — ${state.detail ?? (state.active ? "active" : "inactive")}, ${startsAtLogin
+                ? "starts at login."
+                : `does not start at login — \`${app.command} ${unit.profile} server install\` turns that on.`}`
             : `No unit installed — \`${app.command} ${unit.profile} server install\` adds one, for starting under systemd or launchd.`;
         say({
             profile: unit.profile,
@@ -248,6 +252,7 @@ export const serverCommand = (messenger, options = {}) => {
             ...(gaveUp !== undefined
                 ? { stopped: { exitCode: gaveUp, reason: gaveUpReason ?? null, restarts: false } }
                 : {}),
+            startsAtLogin,
             unit: { name: unit.name, path: unit.path, installed: isInstalled, ...state },
             flood: { deadlines: flood.deadlines, sendBlock: flood.sendBlock ?? null },
         }, [
@@ -293,16 +298,28 @@ export const serverCommand = (messenger, options = {}) => {
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server install`],
     }))
-        .description("write a systemd user unit or a launchd agent for this profile; starts nothing")
-        .action(function () {
-        const { context, platform, unit, say } = prepare(this);
+        .summary("install this profile's background server to start at every login")
+        .description("write a systemd user unit or a launchd agent for this profile and have it start at every login; starts nothing now")
+        .action(async function () {
+        const { context, platform, unit, each, say } = prepare(this);
         const replaced = existsSync(unit.path);
         writeSecurely(unit.path, platform.text(unit, app), 0o644);
         platform.prepare?.(unit);
-        say({ profile: unit.profile, unit: unit.name, path: unit.path, command: unit.command, replaced }, [
-            `${replaced ? "Rewrote" : "Wrote"} ${tilde(unit.path, context.env)} — nothing started.`,
+        // A unit of moved folders runs a development checkout, which must not start at every login on the owner's keyring.
+        const moved = Object.keys(locationVariables(app, context.env)).length > 0;
+        if (!moved)
+            await each(platform.install(unit));
+        say({
+            profile: unit.profile,
+            unit: unit.name,
+            path: unit.path,
+            command: unit.command,
+            replaced,
+            startsAtLogin: !moved,
+        }, [
+            `${replaced ? "Rewrote" : "Wrote"} ${tilde(unit.path, context.env)} — ${moved ? "with moved folders it does not start at login" : "it starts at every login"}, nothing started now.`,
             `It runs: ${unit.command.map((word) => tilde(word, context.env)).join(" ")}`,
-            `Start it now: ${app.command} ${unit.profile} server start · ${platform.atLogin(unit)}`,
+            `Start it now: ${app.command} ${unit.profile} server start · never at login: ${app.command} ${unit.profile} server uninstall`,
             // Suggested, never turned on: an agent reading chats every morning is the owner's choice (NEED-161).
             `A daily follow-up review is off. To turn it on: ${app.command} ${unit.profile} schedule agent follow-ups claude "${followUpsPrompt(app.command)}" --at 08:30`,
         ]);
@@ -311,13 +328,14 @@ export const serverCommand = (messenger, options = {}) => {
         effects: LOCAL_WRITE,
         examples: [`${app.command} personal server uninstall`],
     }))
-        .description("remove this profile's unit; stop it first")
+        .description("remove this profile's unit, so it no longer starts at login; stop it first")
         .action(async function () {
-        const { context, platform, unit, say } = prepare(this);
+        const { context, platform, unit, each, say } = prepare(this);
         installed(unit);
         if ((await platform.state(unit)).active) {
             throw new CliError("validation_error", `the unit is running — \`${app.command} ${unit.profile} server stop\` first`);
         }
+        await each(platform.uninstall(unit));
         rmSync(unit.path, { force: true });
         say({ profile: unit.profile, unit: unit.name, path: unit.path, removed: true }, [
             `Removed ${tilde(unit.path, context.env)}.`,

package/dist/cli/payment-query.d.ts

@@ -0,0 +1,8 @@
+import type { PaymentFilter } from "../store/store.js";
+/**
+ * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
+ * (proposed, accepted).
+ */
+export declare const PAYMENT_QUERY_FIELDS: import("@wirecat/cli-base/query").FieldSpec[];
+/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
+export declare const paymentFilterOf: (terms: Map<string, string>) => PaymentFilter | undefined;

package/dist/cli/payment-query.js

@@ -0,0 +1,27 @@
+import { CliError } from "@wirecat/cli-base";
+import { PAYMENT_DIRECTIONS, PAYMENT_STATES } from "../meetings/index.js";
+import { termField } from "./list-query.js";
+/**
+ * The terms a facts list adds for payments. `state` is the payment's, not `status`, which stays the review status
+ * (proposed, accepted).
+ */
+export const PAYMENT_QUERY_FIELDS = [
+    termField("open", "bool", "open:true"),
+    termField("direction", "enum", "direction:to_us", { values: PAYMENT_DIRECTIONS }),
+    termField("state", "enum", "state:paid", { values: PAYMENT_STATES }),
+];
+/** The store's payment filter from `queryTerms`' answer; `undefined` when no payment term was given. */
+export const paymentFilterOf = (terms) => {
+    const open = terms.get("open");
+    const direction = terms.get("direction");
+    const state = terms.get("state");
+    if (open === undefined && direction === undefined && state === undefined)
+        return undefined;
+    if (open !== undefined && open !== "true" && open !== "false")
+        throw new CliError("validation_error", "open takes true or false");
+    return {
+        ...(open === undefined ? {} : { open: open === "true" }),
+        ...(direction === undefined ? {} : { direction }),
+        ...(state === undefined ? {} : { state }),
+    };
+};

package/dist/cli/program.js

@@ -192,11 +192,15 @@ const runOnce = async (argv, definition, options) => {
     };
     const sigint = () => interrupted("SIGINT");
     const sigterm = () => interrupted("SIGTERM");
+    // A sync, or a one-shot's wait on work it started (`schedule run`), outlives its reader: a desktop that closed the
+    // pipe 18 minutes in must not lose the sync, and the run record still says how it ended. Its later lines go
+    // nowhere. A listening command's stream is its work, so it still ends.
+    let outlivesReader = false;
     const pipeError = (error) => {
-        if (error.code === "EPIPE") {
-            signalExit = 0;
-            control.abort(error);
-        }
+        if (error.code !== "EPIPE" || outlivesReader || (phased && !listens))
+            return;
+        signalExit = 0;
+        control.abort(error);
     };
     const externalAbort = () => {
         const cancelled = new CliError("cancelled", "command cancelled", { retryable: false });
@@ -343,6 +347,7 @@ const runOnce = async (argv, definition, options) => {
         const { lifetime, cooperative: stopsAtItsPace, partial: answersPartial } = metaOf(action);
         const persistent = lifetime === "persistent";
         listens = persistent;
+        outlivesReader = stopsAtItsPace === true;
         const interactiveLogin = !headless && lifetime === "interactive";
         const timeout = flags.timeout ?? (commandEnv[envName(definition.app, "TIMEOUT")]?.trim() || undefined);
         // A background fetch was asked to outlive the shell; only an explicit --timeout bounds it.

package/dist/cli/project-status-rows.d.ts

@@ -0,0 +1,8 @@
+import type { RowShape } from "./compact.js";
+/**
+ * The compact row of each status signal's items, by `status.<signal id>`; a signal's file and its row are the two
+ * places a new signal touches. They live here because a service may not import the CLI's row type.
+ */
+export declare const STATUS_SIGNAL_ROWS: Readonly<Record<string, RowShape>>;
+/** The rest of a `project_status` answer: its chats, open money, chats left out, and failed signals. */
+export declare const STATUS_ROWS: Readonly<Record<string, RowShape>>;

package/dist/cli/project-status-rows.js

@@ -0,0 +1,102 @@
+const where = [{ field: "ref" }, { field: ["chat_title", "chat"] }];
+const who = { field: ["who.owner", "who.name"], tag: "you" };
+/**
+ * The compact row of each status signal's items, by `status.<signal id>`; a signal's file and its row are the two
+ * places a new signal touches. They live here because a service may not import the CLI's row type.
+ */
+export const STATUS_SIGNAL_ROWS = {
+    "status.last-message": { columns: [...where, { field: "at", as: "time" }, who] },
+    "status.reply-next": {
+        columns: [
+            ...where,
+            { field: "data.next" },
+            { field: "data.addressed.name" },
+            { field: "data.waiting_since", as: "day" },
+            { field: "data.overdue", tag: "overdue" },
+        ],
+    },
+    "status.questions": {
+        columns: [...where, { field: "at", as: "day" }, { field: "data.side" }, who],
+        text: ["data.excerpt"],
+    },
+    "status.promises": {
+        columns: [
+            ...where,
+            { field: "at", as: "day" },
+            { field: "data.source" },
+            { field: "data.side" },
+            { field: "data.due", as: "day" },
+            { field: "data.status" },
+        ],
+        text: ["data.title"],
+    },
+    "status.amounts": {
+        columns: [
+            ...where,
+            { field: "data.direction" },
+            { field: "data.amount" },
+            { field: "data.currency" },
+            { field: "data.state" },
+            { field: "data.since", as: "day" },
+            { field: "data.asks", as: "count", tag: "asks" },
+            { field: "basis" },
+        ],
+    },
+    "status.payments": {
+        columns: [{ field: "ref" }, { field: "at", as: "day" }, { field: "data.status" }],
+        text: ["data.title"],
+    },
+    "status.topics": {
+        columns: [
+            ...where,
+            { field: "data.query" },
+            { field: "data.theirs_last", as: "day" },
+            { field: "data.yours_last", as: "day" },
+            { field: "data.silent_since", as: "day" },
+        ],
+    },
+    "status.coverage": {
+        columns: [
+            { field: "chat" },
+            { field: "chat_title" },
+            { field: "data.state" },
+            { field: "data.held.messages", as: "count", tag: "held" },
+            { field: "data.held.oldest_at", as: "day" },
+            { field: "sync_command" },
+        ],
+    },
+    "status.children": {
+        columns: [
+            { field: "data.child" },
+            { field: "data.key" },
+            { field: "data.name" },
+            { field: "data.chats", as: "count", tag: "chats" },
+            { field: "data.cut" },
+        ],
+    },
+};
+/** The rest of a `project_status` answer: its chats, open money, chats left out, and failed signals. */
+export const STATUS_ROWS = {
+    ...STATUS_SIGNAL_ROWS,
+    "status.chat": {
+        columns: [
+            { field: "chat" },
+            { field: "title" },
+            { field: "kind" },
+            { field: "role" },
+            { field: "attention", as: "count", tag: "attention" },
+            { field: "why" },
+        ],
+    },
+    "status.money": {
+        columns: [
+            { field: "direction" },
+            { field: "amount" },
+            { field: "currency" },
+            { field: "rows", as: "count", tag: "rows" },
+        ],
+    },
+    "status.signal": { columns: [{ field: "id" }, { field: "version" }] },
+    "status.out-of-scope": { columns: [{ field: "chat" }, { field: "reason" }, { field: "purpose" }] },
+    "status.failed": { columns: [{ field: "signal" }], text: ["why"] },
+};

package/dist/cli/project-status.d.ts

@@ -0,0 +1,132 @@
+import type { NextStep } from "@wirecat/cli-base/standards";
+import * as v from "valibot";
+import type { ProjectStatus, StatusChatSummary } from "../services/project-status/index.js";
+import type { RowShape } from "./compact.js";
+export interface ProjectStatusHints {
+    /** The step that syncs a chat held in part back to `since` (`YYYY-MM-DD`); null when no command here can. */
+    sync: (chat: StatusChatSummary, since: string) => NextStep | null;
+    /** The step that reads a chat's stored messages from `since`; null when no command here can. */
+    read: (chat: StatusChatSummary, since: string) => NextStep | null;
+    /** The command line a step runs, for the text form. */
+    line: (step: NextStep) => string;
+}
+/** The `project_status` answer drawn by `--compact`: each signal's list with that signal's row. */
+export declare const projectStatusRow: (signals: readonly {
+    id: string;
+}[]) => RowShape;
+/** Where a project stands: per chat signals, open money, and what was left out. Empty lists are left out. */
+export declare const projectStatusSchema: v.LooseObjectSchema<{
+    readonly project: v.StringSchema<undefined>;
+    readonly key: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly name: v.StringSchema<undefined>;
+    readonly window: v.StrictObjectSchema<{
+        readonly since: v.StringSchema<undefined>;
+        readonly until: v.StringSchema<undefined>;
+    }, undefined>;
+    readonly signals: v.ArraySchema<v.StrictObjectSchema<{
+        readonly id: v.StringSchema<undefined>;
+        readonly version: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly money: v.ArraySchema<v.StrictObjectSchema<{
+        readonly direction: v.StringSchema<undefined>;
+        readonly currency: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly amount: v.StringSchema<undefined>;
+        readonly rows: v.NumberSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly chats: v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly kind: v.StringSchema<undefined>;
+        readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly purpose: v.StringSchema<undefined>;
+        readonly project: v.StringSchema<undefined>;
+        readonly coverage: v.StringSchema<undefined>;
+        readonly attention: v.NumberSchema<undefined>;
+        readonly why: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly out_of_scope: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly chat: v.StringSchema<undefined>;
+        readonly reason: v.StringSchema<undefined>;
+        readonly purpose: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly failed: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly signal: v.StringSchema<undefined>;
+        readonly why: v.StringSchema<undefined>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+export type ProjectStatusItem = v.InferOutput<typeof projectStatusSchema>;
+/** The answer of `projects status`: the item, two steps at most, what is missing, and the window. */
+export declare const projectStatusAnswer: (found: ProjectStatus, hints: ProjectStatusHints) => {
+    item: {
+        project: string;
+        key: string | null;
+        name: string;
+        window: {
+            since: string;
+            until: string;
+        };
+        signals: {
+            id: string;
+            version: number;
+        }[];
+        money: {
+            direction: string;
+            currency: string | null;
+            amount: string;
+            rows: number;
+        }[];
+        chats: {
+            chat: string;
+            title: string | null;
+            kind: string;
+            role: string | null;
+            purpose: string;
+            project: string;
+            coverage: string;
+            attention: number;
+            why: string | null;
+        }[];
+        out_of_scope?: {
+            chat: string;
+            reason: string;
+            purpose?: string | undefined;
+        }[] | undefined;
+        failed?: {
+            signal: string;
+            why: string;
+        }[] | undefined;
+    } & {
+        [key: string]: unknown;
+    };
+    next: ({
+        kind: "command";
+        step: string;
+        command: string;
+        args: {
+            [x: string]: unknown;
+        };
+        line?: string | undefined;
+        why: string;
+        safe_to_auto_execute: boolean;
+    } | {
+        kind: "user_action";
+        step: string;
+        why: string;
+        safe_to_auto_execute: false;
+    })[];
+    missing: {
+        field: string;
+        why: string;
+        step?: string | undefined;
+    }[];
+    meta: {
+        window: {
+            since: string;
+            until: string;
+        };
+        complete: boolean;
+        accounts?: string[] | undefined;
+    };
+};
+/** The human form: header, money, a line per chat with what is open, then the steps. */
+export declare const projectStatusText: (found: ProjectStatus, hints: ProjectStatusHints) => string;