@wirecat/cli-core 0.452.0 → 0.454.0

package/dist/entities/task-results.d.ts

@@ -37,9 +37,9 @@ export declare const taskCard: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+        readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -51,9 +51,9 @@ export declare const taskCard: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+        readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -138,9 +138,9 @@ export declare const taskCreated: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -152,9 +152,9 @@ export declare const taskCreated: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -240,9 +240,9 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+        readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -254,9 +254,9 @@ export declare const taskLinks: v.UnionSchema<[v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-        readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-        readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+        readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
         readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -370,9 +370,9 @@ export declare const taskMerge: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -384,9 +384,9 @@ export declare const taskMerge: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -465,9 +465,9 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -479,9 +479,9 @@ export declare const taskUnmerge: v.StrictObjectSchema<{
             readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>, undefined>;
-            readonly kind: v.PicklistSchema<["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+            readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
             readonly anchor: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly origin: v.PicklistSchema<["file", "owner", "suggested", "message"], undefined>;
+            readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message", "calendar"], undefined>;
             readonly target_text: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly role: v.NullableSchema<v.StringSchema<undefined>, undefined>;
             readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;

package/dist/entities/task-results.js

@@ -1,5 +1,6 @@
 import * as v from "valibot";
 import { TASK_TYPES } from "../domain/knowledge.js";
+import { LINK_KINDS, LINK_SOURCES } from "../store/sqlite/link-kinds.js";
 import { TASK_KINDS, TASK_ORIGINS, TASK_STATES, TASK_VERDICTS } from "../tasks/index.js";
 import { count, id, reference, text, time } from "./fields.js";
 import { closeSuggestion } from "./task.js";
@@ -9,22 +10,9 @@ const link = v.strictObject({
     id,
     from: reference,
     to: v.nullable(reference),
-    kind: v.picklist([
-        "links-to",
-        "blocked-by",
-        "follow-up-of",
-        "about",
-        "member-of",
-        "labelled",
-        "answered-by",
-        "evidence",
-        "created-from",
-        "duplicate-of",
-        "related-to",
-        "assigned-to",
-    ]),
+    kind: v.picklist(LINK_KINDS),
     anchor: v.nullable(text),
-    origin: v.picklist(["file", "owner", "suggested", "message"]),
+    origin: v.picklist(LINK_SOURCES),
     target_text: v.nullable(text),
     role: v.nullable(text),
     evidence: v.nullable(text),

package/dist/mcp/http/activity.d.ts

@@ -0,0 +1,24 @@
+/** What each logged-in app did last, keyed by its client id. Tool names and times only: never arguments. */
+export interface ClientActivity {
+    lastRequestAt: string;
+    lastTool?: string;
+    lastToolAt?: string;
+    /** The local day `toolCalls` counts, `YYYY-MM-DD`. */
+    day: string;
+    toolCalls: number;
+}
+export type Activity = Record<string, ClientActivity>;
+export declare const httpActivityFile: (tokenFile: string) => string;
+export declare const localDay: (ms: number) => string;
+export declare const readActivity: (path: string) => Activity;
+/** The names of the tools a JSON-RPC body calls; a batch may call several. */
+export declare const calledTools: (body: unknown) => string[];
+/**
+ * Keeps the activity file of one running server. A call is written at once, so status shows it while the owner
+ * watches; other requests at most every two seconds. Its own file, not the token file: `mcp --revoke` rewrites that
+ * from another process.
+ */
+export declare const activityRecorder: (path: string, now?: () => number) => {
+    record: (clientId: string, tools: string[]) => void;
+    flush: () => void;
+};

package/dist/mcp/http/activity.js

@@ -0,0 +1,86 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+const WRITE_EVERY_MS = 2000;
+/** Any app may send any name; one that does not look like a tool's is not kept. */
+const TOOL_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+export const httpActivityFile = (tokenFile) => `${tokenFile.replace(/\.json$/, "")}.activity.json`;
+export const localDay = (ms) => {
+    const d = new Date(ms);
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+};
+export const readActivity = (path) => {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+};
+/** The names of the tools a JSON-RPC body calls; a batch may call several. */
+export const calledTools = (body) => (Array.isArray(body) ? body : [body]).flatMap((message) => {
+    if (!message || typeof message !== "object")
+        return [];
+    const { method, params } = message;
+    const name = params?.name;
+    return method === "tools/call" && typeof name === "string" && TOOL_NAME.test(name) ? [name] : [];
+});
+/**
+ * Keeps the activity file of one running server. A call is written at once, so status shows it while the owner
+ * watches; other requests at most every two seconds. Its own file, not the token file: `mcp --revoke` rewrites that
+ * from another process.
+ */
+export const activityRecorder = (path, now = Date.now) => {
+    const activity = readActivity(path);
+    let timer;
+    const write = () => {
+        timer = undefined;
+        try {
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+            const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+            writeFileSync(temporary, JSON.stringify(activity), { mode: 0o600, flag: "wx" });
+            chmodSync(temporary, 0o600);
+            renameSync(temporary, path);
+        }
+        catch {
+            // Activity is a convenience for the owner; serving must not fail over it.
+        }
+    };
+    return {
+        record: (clientId, tools) => {
+            const at = now();
+            const iso = new Date(at).toISOString();
+            const day = localDay(at);
+            const before = activity[clientId];
+            const counted = before?.day === day ? before.toolCalls : 0;
+            const last = tools.at(-1);
+            activity[clientId] = {
+                lastRequestAt: iso,
+                day,
+                toolCalls: counted + tools.length,
+                ...(last
+                    ? { lastTool: last, lastToolAt: iso }
+                    : before?.lastTool
+                        ? { lastTool: before.lastTool, ...(before.lastToolAt ? { lastToolAt: before.lastToolAt } : {}) }
+                        : {}),
+            };
+            if (last) {
+                clearTimeout(timer);
+                write();
+            }
+            else if (!timer) {
+                timer = setTimeout(write, WRITE_EVERY_MS);
+                timer.unref();
+            }
+        },
+        flush: () => {
+            if (!timer)
+                return;
+            clearTimeout(timer);
+            write();
+        },
+    };
+};

package/dist/mcp/http/serve.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createMcpHandler, getOAuthProtectedResourceMetadataUrl, hostHeaderValidationResponse, isLegacyRequest, oauthMetadataResponse, requireBearerAuth, WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/server";
 import { CliError } from "@wirecat/cli-base";
 import { listen } from "../../http/listen.js";
+import { activityRecorder, calledTools, httpActivityFile } from "./activity.js";
 import { ownerLogin } from "./oauth.js";
 import { httpLock } from "./state.js";
 export const MCP_PATH = "/mcp";
@@ -74,6 +75,16 @@ const metadataRequest = (request, path, base) => {
     url.pathname = inserted ? AS_METADATA : path;
     return new Request(url, { method: request.method, headers: request.headers });
 };
+const toolsIn = async (request) => {
+    if (request.method !== "POST")
+        return [];
+    try {
+        return calledTools(await request.clone().json());
+    }
+    catch {
+        return [];
+    }
+};
 /**
  * MCP over Streamable HTTP on 127.0.0.1, behind the owner's tunnel (CLI-58). Every MCP request needs
  * a token from the owner login; the Host header must be the tunnel's or this machine's, so a page in
@@ -116,6 +127,7 @@ export const serveOverHttp = async (build, options) => {
         verifier: login.verifier,
         resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource),
     });
+    const activity = activityRecorder(httpActivityFile(tokenFile), now);
     const allowedHosts = [...new Set([publicUrl.hostname, ...LOCAL])];
     const allowedOrigins = [publicUrl.origin];
     const listening = await listen(async (request) => {
@@ -145,6 +157,7 @@ export const serveOverHttp = async (build, options) => {
         const auth = await bearer(request);
         if (auth instanceof Response)
             return auth;
+        activity.record(auth.clientId, await toolsIn(request));
         return (await isLegacyRequest(request)) ? legacy.handle(request, auth) : mcp.fetch(request, { authInfo: auth });
     }, { host: "127.0.0.1", port }).catch((error) => {
         login.close();
@@ -156,6 +169,7 @@ export const serveOverHttp = async (build, options) => {
         url: listening.url,
         close: async () => {
             login.close();
+            activity.flush();
             try {
                 await listening.close();
                 await legacy.close();

package/dist/mcp/http/state.d.ts

@@ -44,6 +44,11 @@ export interface SignedInClient {
     /** What the app said its name was when it registered — anyone may register, so it proves nothing. */
     claimedName: string | null;
     lastLoginAt: string;
+    /** Any MCP request with its token, so the app reached the server after logging in. */
+    lastRequestAt: string | null;
+    lastTool: string | null;
+    lastToolAt: string | null;
+    toolCallsToday: number;
 }
 /**
  * The apps that hold a token now, and when each last got one. Ids and hashes stay in the file: what

package/dist/mcp/http/state.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { holdLock, readLock, releaseLock, takeLock } from "../../background/lock.js";
+import { httpActivityFile, localDay, readActivity } from "./activity.js";
 export const ACCESS_SECONDS = 60 * 60;
 export const REFRESH_SECONDS = 30 * 24 * 60 * 60;
 export const readStored = (path) => existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : { clients: [], tokens: [] };
@@ -32,6 +33,8 @@ export const httpLock = (path, first) => {
 export const signedInClients = (tokenFile, now = Date.now()) => {
     const seconds = Math.floor(now / 1000);
     const { clients, tokens } = readStored(tokenFile);
+    const activity = readActivity(httpActivityFile(tokenFile));
+    const today = localDay(now);
     const last = new Map();
     for (const token of tokens) {
         if (token.expiresAt <= seconds)
@@ -41,9 +44,16 @@ export const signedInClients = (tokenFile, now = Date.now()) => {
     }
     return clients
         .filter((client) => last.has(client.id))
-        .map((client) => ({
-        claimedName: client.name ?? null,
-        lastLoginAt: new Date((last.get(client.id) ?? 0) * 1000).toISOString(),
-    }))
+        .map((client) => {
+        const did = activity[client.id];
+        return {
+            claimedName: client.name ?? null,
+            lastLoginAt: new Date((last.get(client.id) ?? 0) * 1000).toISOString(),
+            lastRequestAt: did?.lastRequestAt ?? null,
+            lastTool: did?.lastTool ?? null,
+            lastToolAt: did?.lastToolAt ?? null,
+            toolCallsToday: did?.day === today ? did.toolCalls : 0,
+        };
+    })
         .sort((a, b) => b.lastLoginAt.localeCompare(a.lastLoginAt));
 };

package/dist/meetings/event-store.d.ts

@@ -30,6 +30,20 @@ export interface EntryParticipantInput {
     /** A room or a piece of equipment: listed, never a contact. */
     resource?: boolean;
 }
+/** A Google Drive file attached to a calendar entry (Google's `attachments[]`). */
+export interface EntryAttachmentInput {
+    /** The Drive file's id: `files.external_id` of a stored Drive file. */
+    fileId: string;
+    title?: string | null;
+}
+/** A Drive file attached to an entry, and the document it is once Drive has stored it. */
+export interface EntryAttachment {
+    entryId: number;
+    fileId: string;
+    title: string | null;
+    /** `null` while no Drive account holds the file, while two do, or while its document is deleted. */
+    documentId: number | null;
+}
 export type EntryKind = "single" | "series" | "occurrence";
 export type EntryStatus = "confirmed" | "tentative" | "cancelled";
 /**
@@ -75,6 +89,12 @@ export interface EntryInput {
     externalUpdatedAt?: number | null;
     /** Only the keys `ENTRY_METADATA_KEYS` names are kept. */
     metadata?: Record<string, unknown> | null;
+    /**
+     * Its Drive files: each links the entry to the file's document, now or once Drive stores the file. Absent keeps the
+     * links the entry has; a list replaces them. Google leaves `attachments` out of an event that has none, so a provider
+     * sending a whole event sends `[]` then, or a file removed from the event stays linked.
+     */
+    attachments?: EntryAttachmentInput[];
 }
 export interface StoredEntry {
     id: number;
@@ -138,6 +158,7 @@ export interface EventDetails {
     entries: StoredEntry[];
     participants: StoredParticipant[];
     revisions: EntryRevision[];
+    attachments: EntryAttachment[];
 }
 export interface EventFilter {
     /** Events that end after this instant (exclusive end). */
@@ -148,6 +169,8 @@ export interface EventFilter {
     calendarId?: number;
     /** Events whose entries list one of this person's contacts. */
     personId?: number;
+    /** Latest start first; earliest first when absent. */
+    newest?: boolean;
     limit?: number;
     offset?: number;
 }

package/dist/meetings/index.d.ts

@@ -4,7 +4,7 @@ export { calendarText, ENTRY_METADATA_KEYS, entryMetadata, withoutLinkQueries }
 export type { MeetingContextStore, MeetingEventLinkInput, MeetingEventLinkReceipt, ParticipantPerson, ParticipantPersonInput, ParticipantPersonLinkInput, ParticipantPersonLinkReceipt, } from "./context-store.js";
 export { type MeetingCueIdentity, meetingCueFingerprint } from "./cue-fingerprint.js";
 export { EVENT_QUERY } from "./event-query.js";
-export type { CalendarInput, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EventDetails, EventFilter, EventStore, LinkReview, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
+export type { CalendarInput, EntryAttachment, EntryAttachmentInput, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EventDetails, EventFilter, EventStore, LinkReview, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/search/query.js

@@ -27,9 +27,7 @@ export const sourceOf = (name, value, providers) => {
         return source;
     if (isKind(source))
         fail(`${name}${source} names ${source}, which a message search does not read — ` +
-            (source === "events"
-                ? "no search reads them yet"
-                : `search ${source === "meetings" ? "all --source meetings" : "notes"} does`));
+            `search ${source === "meetings" || source === "events" ? `all --source ${source}` : "notes"} does`);
     const named = providerNamed(source);
     if (named && providers.includes(named.name))
         return named.name;

package/dist/services/events-search.d.ts

@@ -0,0 +1,67 @@
+import type { WarmEmbedders } from "../embeddings/embed.js";
+import type { EventHit } from "../store/index.js";
+import type { AccountKey, MessageStore } from "../store/store.js";
+export interface EventsQuery {
+    limit?: number;
+    offset?: number;
+    /** Calendar accounts to read; every one the store holds when absent. */
+    accounts?: readonly AccountKey[];
+    /** Every word as written: no stems. */
+    exact?: boolean;
+    /** Latest start first instead of best first. */
+    newest?: boolean;
+    /** For `date:`, which reads an event's start — the zone a bare day is read in. */
+    timezone?: string;
+    signal?: AbortSignal;
+    /** How many matching events are read before grouping; for tests. */
+    candidates?: number;
+    env?: NodeJS.ProcessEnv;
+    /** The tool's command, named in the hint when the model is missing. */
+    command?: string;
+    /** The search's own models, when another part of it loads the same one. */
+    embedders?: Pick<WarmEmbedders, "get">;
+}
+export interface FoundEvent {
+    /** `event:<id>`, of the occurrence shown: of a series, the match nearest now that is not cancelled. */
+    ref: string;
+    /** The calendar account it is in; `null` for an event no calendar holds, such as a Zoom meeting's own. */
+    provider: string | null;
+    account: string | null;
+    title: string | null;
+    starts_at: string | null;
+    ends_at: string | null;
+    all_day: boolean;
+    /** confirmed, tentative or cancelled. */
+    status: string | null;
+    location: string | null;
+    /** The event's page at the calendar. */
+    url?: string;
+    /** Around the first word of the query in its description, place and attendees. */
+    excerpt: string;
+    /** How many occurrences of its series matched; 1 for an event that does not repeat. */
+    occurrences: number;
+    /** When the store's copy last changed. */
+    updated_at: string;
+    found_by: ("words" | "meaning")[];
+}
+export interface EventsFound {
+    query: string;
+    /** Words and word stems always; meaning too when the model is there and the query is plain words. */
+    by: "words" | "words and meaning";
+    /** Why meaning was not searched, when it was not. */
+    meaning_skipped?: string;
+    hits: FoundEvent[];
+    has_more: boolean;
+    /** More events matched than one search reads (50,000); the later ones were not read — narrow the query. */
+    truncated?: true;
+    next_offset?: number;
+}
+/** The calendar accounts the store holds: every account whose provider is of the `events` kind. */
+export declare const calendarAccounts: (store: MessageStore) => Promise<AccountKey[]>;
+export declare const foundEvent: (hit: Omit<EventHit, "relevance">, query: string, foundBy: FoundEvent["found_by"]) => FoundEvent;
+/**
+ * Calendar events by words and, when the local text model is there and the query is plain words, by meaning, merged
+ * by reciprocal rank: title, cleaned description, place and attendees' names. The occurrences of one series are one
+ * hit. Working location, focus time, out of office, birthdays and busy-only slots are never found.
+ */
+export declare const searchEvents: (store: MessageStore, query: string, { limit, offset, accounts, exact, newest, timezone, signal, candidates, env, command, embedders, }?: EventsQuery) => Promise<EventsFound>;