minutes-mcp 0.21.0 → 0.22.0

package/dist/captureRelay.d.ts

@@ -0,0 +1,35 @@
+export interface CaptureRelayCursor {
+    session_id?: string;
+    transcript_seq: number;
+    nudge_seq: number;
+}
+export interface CaptureRelayDiscovery {
+    v: number;
+    session_id: string;
+    transport: "unix_socket" | "windows_named_pipe";
+    endpoint: string;
+    owner_pid: number;
+    evidence_mode: string;
+    auth_token: string;
+    started_at: string;
+    heartbeat_at: string;
+}
+export interface CaptureRelayFrame {
+    type: string;
+    seq?: number;
+    session_id?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+export interface CaptureRelaySnapshot {
+    discovery: Omit<CaptureRelayDiscovery, "auth_token">;
+    cursor: CaptureRelayCursor;
+    frames: CaptureRelayFrame[];
+}
+export interface CaptureRelayAttachOptions {
+    discoveryPath?: string;
+    timeoutMs?: number;
+    replayQuietMs?: number;
+}
+export declare function captureRelayDiscoveryPath(): string;
+export declare function attachCaptureRelay(cursor?: CaptureRelayCursor, options?: CaptureRelayAttachOptions): Promise<CaptureRelaySnapshot>;

package/dist/captureRelay.js

@@ -0,0 +1,181 @@
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createConnection } from "node:net";
+const RELAY_PROTOCOL_VERSION = 1;
+const HEARTBEAT_STALE_MS = 5_000;
+export function captureRelayDiscoveryPath() {
+    return join(homedir(), ".minutes", "capture-relay.json");
+}
+export async function attachCaptureRelay(cursor = { transcript_seq: 0, nudge_seq: 0 }, options = {}) {
+    const discoveryPath = options.discoveryPath ?? captureRelayDiscoveryPath();
+    const discovery = await readAndValidateDiscovery(discoveryPath);
+    const timeoutMs = options.timeoutMs ?? 1_000;
+    const replayQuietMs = options.replayQuietMs ?? 40;
+    return await new Promise((resolvePromise, rejectPromise) => {
+        let socket;
+        let settled = false;
+        let acknowledged = false;
+        let buffer = "";
+        let quietTimer;
+        const frames = [];
+        const nextCursor = {
+            session_id: cursor.session_id,
+            transcript_seq: cursor.transcript_seq,
+            nudge_seq: cursor.nudge_seq,
+        };
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutTimer);
+            if (quietTimer)
+                clearTimeout(quietTimer);
+            socket?.destroy();
+            if (error) {
+                rejectPromise(error);
+                return;
+            }
+            resolvePromise({
+                discovery: redactDiscovery(discovery),
+                cursor: nextCursor,
+                frames,
+            });
+        };
+        const scheduleReplayComplete = () => {
+            if (!acknowledged)
+                return;
+            if (quietTimer)
+                clearTimeout(quietTimer);
+            quietTimer = setTimeout(() => finish(), replayQuietMs);
+        };
+        const timeoutTimer = setTimeout(() => finish(new Error("the capture attachment relay did not respond in time")), timeoutMs);
+        socket = createConnection(discovery.endpoint);
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            socket?.write(`${JSON.stringify({
+                v: RELAY_PROTOCOL_VERSION,
+                auth_token: discovery.auth_token,
+                action: { type: "observe", cursor },
+            })}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            while (true) {
+                const newline = buffer.indexOf("\n");
+                if (newline < 0)
+                    break;
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                if (!line)
+                    continue;
+                let frame;
+                try {
+                    frame = JSON.parse(line);
+                }
+                catch {
+                    finish(new Error("the capture attachment relay sent invalid data"));
+                    return;
+                }
+                if (frame.type === "error") {
+                    finish(new Error(String(frame.message ?? "capture attachment failed")));
+                    return;
+                }
+                if (!acknowledged) {
+                    if (frame.type !== "attached" && frame.type !== "cursor_reset") {
+                        finish(new Error("the capture attachment relay did not acknowledge this client"));
+                        return;
+                    }
+                    acknowledged = true;
+                    nextCursor.session_id = discovery.session_id;
+                }
+                if (frame.type === "cursor_reset") {
+                    nextCursor.session_id = String(frame.session_id ?? discovery.session_id);
+                    nextCursor.transcript_seq = 0;
+                    nextCursor.nudge_seq = 0;
+                }
+                else if (frame.type === "transcript" && typeof frame.seq === "number") {
+                    nextCursor.transcript_seq = Math.max(nextCursor.transcript_seq, frame.seq);
+                }
+                else if (frame.type === "nudge" && typeof frame.seq === "number") {
+                    nextCursor.nudge_seq = Math.max(nextCursor.nudge_seq, frame.seq);
+                }
+                frames.push(frame);
+            }
+            scheduleReplayComplete();
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled && !acknowledged) {
+                finish(new Error("the capture owner closed the attachment relay"));
+            }
+            else if (!settled) {
+                finish();
+            }
+        });
+    });
+}
+async function readAndValidateDiscovery(path) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        throw new Error("no active capture attachment relay was found");
+    }
+    let discovery;
+    try {
+        discovery = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("the capture attachment discovery file is invalid");
+    }
+    if (discovery.v !== RELAY_PROTOCOL_VERSION) {
+        throw new Error(`capture attachment protocol ${discovery.v} is not supported`);
+    }
+    if (!Number.isSafeInteger(discovery.owner_pid) || discovery.owner_pid <= 0) {
+        throw new Error("the capture attachment owner PID is invalid");
+    }
+    const heartbeat = Date.parse(discovery.heartbeat_at);
+    if (!Number.isFinite(heartbeat) || Date.now() - heartbeat > HEARTBEAT_STALE_MS) {
+        throw new Error("the capture attachment heartbeat is stale");
+    }
+    if (!discovery.auth_token || discovery.auth_token.length < 32) {
+        throw new Error("the capture attachment token is invalid");
+    }
+    validateLocalEndpoint(path, discovery);
+    if (process.platform !== "win32") {
+        const mode = (await stat(path)).mode & 0o777;
+        if ((mode & 0o077) !== 0) {
+            throw new Error("the capture attachment discovery file is not private to this user");
+        }
+    }
+    try {
+        process.kill(discovery.owner_pid, 0);
+    }
+    catch (error) {
+        if (error?.code === "ESRCH") {
+            throw new Error(`capture owner process ${discovery.owner_pid} is no longer running`);
+        }
+    }
+    return discovery;
+}
+function validateLocalEndpoint(discoveryPath, discovery) {
+    if (discovery.transport === "windows_named_pipe") {
+        if (!discovery.endpoint.toLowerCase().startsWith("\\\\.\\pipe\\minutes-capture-")) {
+            throw new Error("the capture attachment named pipe is not a Minutes local endpoint");
+        }
+        return;
+    }
+    if (discovery.transport !== "unix_socket") {
+        throw new Error("the capture attachment transport is invalid");
+    }
+    const expected = resolve(dirname(discoveryPath), "capture-relay.sock");
+    if (resolve(discovery.endpoint) !== expected) {
+        throw new Error("the capture attachment socket is outside the private Minutes directory");
+    }
+}
+function redactDiscovery(discovery) {
+    const { auth_token: _authToken, ...safe } = discovery;
+    return safe;
+}

package/dist/index.d.ts

@@ -14,6 +14,7 @@
  *   - activity_summary: Summarize meeting-adjacent desktop context for a session/path/window
  *   - search_context: Search app and captured window-title desktop context
  *   - get_moment: Show the local rewind around a linked artifact, session, or timestamp
+ *   - get_screen_context: Retrieve bounded, session-linked screen images
  *   - consistency_report: Flag conflicting decisions and stale commitments
  *   - get_person_profile: Rich relationship profile for a person (graph index)
  *   - track_commitments: List open/stale commitments, filter by person
@@ -24,6 +25,8 @@
  *   - list_voices: List enrolled voice profiles for speaker identification
  *   - confirm_speaker: Confirm/correct speaker attribution in a meeting
  *   - get_meeting_insights: Query structured insights (decisions, commitments, etc.) with confidence filtering
+ *   - start_copilot / stop_copilot: Control the independent real-time copilot engine
+ *   - copilot_status / read_copilot_nudges: Observe copilot health and cursor-based nudges
  *
  * All tools use execFile (not exec) to shell out to the `minutes` CLI binary.
  * No shell interpolation — safe from injection.
@@ -94,6 +97,61 @@ export declare function shouldRunMainEntry(argv1: string | null | undefined, mod
 export declare function parseKnowledgeConfig(configContent: string): KnowledgeConfigStatus | null;
 export declare const LIVE_EVENTS_RESOURCE_URI = "minutes://events/live";
 export declare const LIVE_EVENTS_URI_TEMPLATE = "minutes://events/live{?since_seq,limit}";
+export declare const LIVE_COPILOT_RESOURCE_URI = "minutes://live/copilot";
+type JsonObject = Record<string, unknown>;
+export type CopilotStatusPayload = {
+    available: boolean;
+    active: boolean;
+    state: string;
+    pid: number | null;
+    goal: string | null;
+    surface: string | null;
+    provider: string | null;
+    model: string | null;
+    evidence_cursor: number;
+    capture_attachment: string | null;
+    last_error: string | null;
+    raw: string;
+    error?: string;
+};
+export type CopilotObserverSession = {
+    v: 1;
+    pid: number;
+    goal: string;
+    surface: "stdout" | "tui";
+    started_ts: string;
+};
+export type ObservedCopilotNudge = {
+    cursor: number;
+    format: "json" | "text" | "raw";
+    nudge: JsonObject;
+    raw: string;
+    observed_ts: string | null;
+    expires_at: string | null;
+    expired: boolean | null;
+};
+export type CopilotNudgeObservation = {
+    attached: boolean;
+    cursor: number;
+    session: CopilotObserverSession | null;
+    nudges: ObservedCopilotNudge[];
+    note: string;
+};
+export type LiveCopilotResourcePayload = {
+    v: 1;
+    resource: typeof LIVE_COPILOT_RESOURCE_URI;
+    available: boolean;
+    active: boolean;
+    state: string;
+    status: CopilotStatusPayload;
+    nudge_stream: {
+        attached: boolean;
+        cursor: number;
+        note: string;
+    };
+    latest_nudge: ObservedCopilotNudge | null;
+    current_nudge: ObservedCopilotNudge | null;
+};
 export type LiveEventsResourceOptions = {
     uri: string;
     sinceSeq: number | null;
@@ -114,10 +172,30 @@ export type LiveEventsResourcePayload = {
 };
 export declare function parseLiveEventsResourceUri(rawUri: string): LiveEventsResourceOptions | null;
 export declare function buildLiveEventsResourcePayload(options: LiveEventsResourceOptions, events: unknown[], latestSeq: number): LiveEventsResourcePayload;
+/** Parse the stable human-readable `minutes copilot status` surface. */
+export declare function parseCopilotStatusOutput(raw: string): CopilotStatusPayload;
+/** Parse the CLI's stdout presentation stream without invoking inference. */
+export declare function parseCopilotNudgeLog(raw: string, nowMs?: number, latestObservedMs?: number): ObservedCopilotNudge[];
+export declare function buildLiveCopilotResourcePayload(status: CopilotStatusPayload, observation: CopilotNudgeObservation): LiveCopilotResourcePayload;
+export type CopilotNudgeReadPage = {
+    cursor: number;
+    next_cursor: number;
+    cursor_reset: boolean;
+    has_more: boolean;
+    nudges: ObservedCopilotNudge[];
+};
+export declare function selectCopilotNudges(observation: CopilotNudgeObservation, options: {
+    cursor?: number;
+    since?: string;
+    limit?: number;
+}, nowMs?: number): CopilotNudgeReadPage;
 export type LiveEventsSubscriptionOptions = {
     pollIntervalMs?: number;
+    enableLiveEvents?: boolean;
+    enableCopilot?: boolean;
     latestEventSeq?: () => Promise<number>;
     readEventsSinceSeq?: (sinceSeq: number, limit: number) => Promise<unknown[]>;
+    copilotFingerprint?: () => Promise<string>;
     sendResourceUpdated?: (uri: string) => Promise<void>;
     onError?: (error: unknown) => void;
 };