@shawnowen/comet-mcp 2.3.1 → 2.4.1

package/dist/snapshot-capture.d.ts

@@ -0,0 +1,3 @@
+import type { AgentSession, TaskThreadSnapshot, SnapshotReason, TaskThreadStatus } from "./types.js";
+export declare function captureTaskThreadSnapshot(session: AgentSession, reason: SnapshotReason, taskStatus?: TaskThreadStatus): Promise<TaskThreadSnapshot>;
+//# sourceMappingURL=snapshot-capture.d.ts.map

package/dist/snapshot-capture.js

@@ -0,0 +1,91 @@
+// Snapshot Capture — Task Thread state preservation before automated closure (Spec 016, FR-003)
+// Captures all tabs, Sidecar threads, window metadata, and task status.
+// Atomic write: temp file → rename to prevent partial captures.
+// If capture fails, caller MUST NOT proceed with close (fail safe).
+import { writeFileSync, renameSync, mkdirSync } from "fs";
+import { join } from "path";
+import { loadBridgeConfig } from "./bridge-config.js";
+export async function captureTaskThreadSnapshot(session, reason, taskStatus = "abandoned") {
+    const config = loadBridgeConfig();
+    const tabs = [];
+    const sidecarThreads = [];
+    let windowMetadata = null;
+    // Query tabs in this session's tab group via extension messaging
+    try {
+        const { tabGroupsClient } = await import("./tab-groups.js");
+        const allTabs = await tabGroupsClient.listTabs();
+        // Filter to tabs in this session's tab group, or by ownership if no group (extension degradation)
+        const sessionTabs = session.tabGroupId !== null
+            ? allTabs.filter((t) => t.groupId === session.tabGroupId)
+            : allTabs.filter((t) => t.id === session.chromeTabId);
+        for (const tab of sessionTabs) {
+            tabs.push({
+                url: tab.url,
+                title: tab.title,
+                chromeTabId: tab.id,
+                targetId: session.targetId,
+                active: tab.active,
+            });
+            // Check if tab has a Sidecar thread (Perplexity assistant panel)
+            if (tab.url?.includes("perplexity.ai")) {
+                sidecarThreads.push({
+                    threadUrl: tab.url,
+                    parentTabUrl: tab.url,
+                    lastQuery: null,
+                });
+            }
+        }
+        // Capture window metadata
+        const groups = await tabGroupsClient.listGroups();
+        const sessionGroup = groups.find((g) => g.id === session.tabGroupId);
+        if (sessionGroup) {
+            windowMetadata = {
+                windowId: sessionGroup.windowId,
+                x: 0,
+                y: -1440,
+                width: 2560,
+                height: 1440,
+                displayIndex: 0,
+            };
+        }
+    }
+    catch (extErr) {
+        // Extension not available — capture what we can from CDP
+        console.warn(`[comet-bridge] Snapshot degraded for ${session.sessionKey}: extension unavailable (${extErr instanceof Error ? extErr.message : extErr})`);
+        tabs.push({
+            url: "unknown (extension unavailable)",
+            title: session.taskThreadId,
+            chromeTabId: session.chromeTabId ?? 0,
+            targetId: session.targetId,
+            active: true,
+        });
+    }
+    const snapshot = {
+        sessionKey: session.sessionKey,
+        agentId: session.agentId,
+        taskThreadId: session.taskThreadId,
+        capturedAt: new Date().toISOString(),
+        reason,
+        taskStatus,
+        tabs,
+        sidecarThreads,
+        windowMetadata,
+        tabGroupId: session.tabGroupId,
+        tabGroupColor: session.tabGroupColor,
+    };
+    // Atomic write: temp file → rename (T026)
+    const snapshotDir = config.cleanup.snapshotDir;
+    mkdirSync(snapshotDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const safeAgentId = session.agentId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const safeThreadId = session.taskThreadId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = `${safeAgentId}_${safeThreadId}_${timestamp}.json`;
+    const finalPath = join(snapshotDir, filename);
+    const tempPath = finalPath + ".tmp";
+    // Write to temp file first — if this fails, no partial snapshot exists
+    writeFileSync(tempPath, JSON.stringify(snapshot, null, 2));
+    // Atomic rename — if this fails, temp file exists but final doesn't
+    renameSync(tempPath, finalPath);
+    return snapshot;
+}
+//# sourceMappingURL=snapshot-capture.js.map

package/dist/tab-group-archive.js

@@ -11,7 +11,9 @@ let writeQueue = Promise.resolve();
 function serialized(fn) {
     const prev = writeQueue;
     let resolve;
-    writeQueue = new Promise((r) => { resolve = r; });
+    writeQueue = new Promise((r) => {
+        resolve = r;
+    });
     return prev.then(fn).finally(() => resolve());
 }
 function resolveArchivePaths(archiveDir) {

package/dist/tab-groups.d.ts

@@ -15,6 +15,11 @@ export interface TabInfo {
     url: string;
     active: boolean;
 }
+export interface WindowTabInfo {
+    tabId: number;
+    windowId: number;
+    url: string;
+}
 export interface CreateGroupOptions {
     tabIds: number[];
     title?: string;
@@ -68,6 +73,8 @@ export declare class TabGroupsClient {
         groupId: number;
         group: TabGroup;
     }>;
+    /** Create a managed browser window locked to the top display fullscreen policy. */
+    createTopDisplayFullscreenWindowWithTab(url: string): Promise<WindowTabInfo>;
     /** Update an existing tab group's title, color, or collapsed state. */
     updateGroup(options: UpdateGroupOptions): Promise<TabGroup>;
     /** Move a tab group to a new position. */

package/dist/tab-groups.js

@@ -116,8 +116,7 @@ export class TabGroupsClient {
             returnByValue: true,
         });
         if (result.exceptionDetails) {
-            const msg = result.exceptionDetails.exception?.description ||
-                result.exceptionDetails.text;
+            const msg = result.exceptionDetails.exception?.description || result.exceptionDetails.text;
             throw new Error(`Extension eval error: ${msg}`);
         }
         return result.result.value;
@@ -163,7 +162,10 @@ export class TabGroupsClient {
         if (Object.keys(updateProps).length > 0) {
           await chrome.tabGroups.update(groupId, updateProps);
         }
-        const g = await chrome.tabGroups.get(groupId);
+        const enforced = await self.CometWindowPolicy.ensureOneGroupPerWindow(groupId, {
+          markChangedWindowManaged: true
+        });
+        const g = enforced?.group || (await chrome.tabGroups.get(groupId));
         return {
           groupId: g.id,
           group: {
@@ -174,6 +176,22 @@ export class TabGroupsClient {
       })()
     `);
     }
+    /** Create a managed browser window locked to the top display fullscreen policy. */
+    async createTopDisplayFullscreenWindowWithTab(url) {
+        return await this.evaluate(`
+      (async () => {
+        const win = await self.CometWindowPolicy.createTopDisplayFullscreenWindow({
+          url: ${JSON.stringify(url)}
+        });
+        const tab = win.tabs?.[0] || (await chrome.tabs.query({ windowId: win.id }))[0];
+        return {
+          tabId: tab.id,
+          windowId: win.id,
+          url: tab.url || tab.pendingUrl || ${JSON.stringify(url)}
+        };
+      })()
+    `);
+    }
     /** Update an existing tab group's title, color, or collapsed state. */
     async updateGroup(options) {
         const props = [];

package/dist/task-thread-aggregator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Task Thread Aggregator — Phase A
+ *
+ * Reads all 5 local layers (lifecycle JSONL, session manifest, archive store,
+ * snapshots, alert log) and synthesises a CanonicalTaskThread for each known
+ * taskThreadId. Exposes the TaskThreadProvider interface so Phase B can swap
+ * the implementation for an equa-taskthreads core API client without touching
+ * any consumers (FR-040).
+ *
+ * Spec: specs/041-task-thread-sync/spec.md
+ * Plan: specs/041-task-thread-sync/plan.md §Layer Aggregator
+ */
+import { CanonicalStatus, CanonicalTaskThread } from "./task-thread-canonical.js";
+/**
+ * The single interface all HTTP route handlers and extension-facing code depends
+ * on. Phase B replaces the LocalTaskThreadAggregator with a CoreAPITaskThreadProvider
+ * without changing any consumer code.
+ */
+export interface TaskThreadProvider {
+    listAll(): Promise<CanonicalTaskThread[]>;
+    get(id: string): Promise<CanonicalTaskThread | null>;
+    executeTransition(id: string, action: string, reason?: string): Promise<{
+        newStatus: CanonicalStatus;
+    }>;
+}
+export declare class LocalTaskThreadAggregator implements TaskThreadProvider {
+    listAll(): Promise<CanonicalTaskThread[]>;
+    get(id: string): Promise<CanonicalTaskThread | null>;
+    executeTransition(id: string, action: string, reason?: string): Promise<{
+        newStatus: CanonicalStatus;
+    }>;
+}
+export declare const aggregator: TaskThreadProvider;
+//# sourceMappingURL=task-thread-aggregator.d.ts.map