@shawnowen/comet-mcp 2.4.1 → 2.4.2

package/dist/tab-groups.js

@@ -243,6 +243,190 @@ export class TabGroupsClient {
       })()
     `);
     }
+    /** List extension-owned descriptions, window labels, archives, and selected metadata. */
+    async listExtensionMetadata() {
+        return await this.evaluate(`
+      (async () => {
+        const stored = await chrome.storage.local.get([
+          "sessionEntityDescriptions",
+          "sidebarSettings",
+          "archivedGroups",
+          "recentlyClosedGroups",
+          "fsSelectedGroups",
+          "fsSelectedTabs"
+        ]);
+        const normalizeArchiveWorkflowStatus = (status) => {
+          const raw = String(status || "").trim().toLowerCase();
+          if (raw === "done") return "done";
+          if (raw === "trashed") return "trashed";
+          return "pending";
+        };
+        const settings = stored.sidebarSettings || {};
+        const archives = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+        return {
+          entityDescriptions: stored.sessionEntityDescriptions || {},
+          windowLabels: settings.windowLabels || {},
+          archives: archives.map((entry) => ({
+            taskThreadId: entry.taskThreadId || entry.id,
+            title: entry.title || entry.sessionName || "Untitled",
+            sessionName: entry.sessionName || null,
+            taskGoal: entry.taskGoal || null,
+            description: String(entry.description || entry.note || ""),
+            status: normalizeArchiveWorkflowStatus(entry.status),
+            rawStatus: entry.status || null,
+            tabCount: Array.isArray(entry.urls) ? entry.urls.length : 0,
+            urls: Array.isArray(entry.urls)
+              ? entry.urls.map((tab) => ({
+                  url: String(tab && tab.url ? tab.url : ""),
+                  title: String(tab && tab.title ? tab.title : ""),
+                  description: String(tab && tab.description ? tab.description : "")
+                }))
+              : [],
+            archivedAt: entry.archivedAt || null,
+            closedAt: entry.closedAt || null,
+            restoredAt: entry.restoredAt || null,
+            orchestratorUrl: entry.orchestratorUrl || null,
+            locked: !!entry.locked,
+            pinned: !!entry.pinned,
+            starred: !!entry.starred
+          })),
+          recentGroups: Array.isArray(stored.recentlyClosedGroups) ? stored.recentlyClosedGroups : [],
+          selectedItems: {
+            groups: Array.isArray(stored.fsSelectedGroups) ? stored.fsSelectedGroups : [],
+            tabs: Array.isArray(stored.fsSelectedTabs) ? stored.fsSelectedTabs : []
+          }
+        };
+      })()
+    `);
+    }
+    /** Update extension-owned metadata without touching native tab state. */
+    async updateExtensionMetadata(options) {
+        const payload = JSON.stringify(options || {});
+        return await this.evaluate(`
+      (async () => {
+        const input = ${payload};
+        const now = new Date().toISOString();
+        const entityType = String(input.entityType || "").toLowerCase();
+        const taskThreadId = String(input.taskThreadId || input.entityId || input.id || "");
+        const makeMetadataAudit = (target) => ({
+          intent: String(input.intent || input.action || "update_metadata"),
+          target,
+          activeWindow: {
+            windowId: String(input.activeWindowId || input.activeWindow?.windowId || "extension_service_worker")
+          },
+          policyTier: String(input.policyTier || "prime"),
+          status: "success",
+          createdAt: now
+        });
+        const coerceArchiveWorkflowStatusForWrite = (status) => {
+          const raw = String(status || "").trim().toLowerCase();
+          if (raw === "saved" || raw === "archived") return "pending";
+          if (raw === "pending" || raw === "done" || raw === "trashed") return raw;
+          throw new Error("Invalid status: " + status);
+        };
+
+        if (entityType === "window" || entityType === "window-label") {
+          const windowId = String(input.windowId || input.entityId || input.id || "");
+          if (!windowId) throw new Error("windowId is required for window metadata updates");
+          const stored = await chrome.storage.local.get("sidebarSettings");
+          const settings = stored.sidebarSettings || {};
+          settings.windowLabels = settings.windowLabels || {};
+          const existingWindowLabel = settings.windowLabels[windowId] || {};
+          const nextWindowLabel = { ...existingWindowLabel };
+          if (input.label !== undefined || input.title !== undefined) {
+            nextWindowLabel.label = String(input.label ?? input.title);
+          }
+          if (typeof nextWindowLabel.label !== "string") {
+            nextWindowLabel.label = String(nextWindowLabel.label ?? "");
+          }
+          settings.windowLabels[windowId] = {
+            ...nextWindowLabel,
+            source: "mcp_metadata",
+            updatedAt: now
+          };
+          await chrome.storage.local.set({ sidebarSettings: settings });
+          return {
+            updated: true,
+            entityType: "window-label",
+            windowId,
+            audit: makeMetadataAudit({ entityType: "window-label", windowId })
+          };
+        }
+
+        if (entityType === "archive" || entityType === "task-thread") {
+          if (!taskThreadId) throw new Error("taskThreadId is required for archive metadata updates");
+          const stored = await chrome.storage.local.get("archivedGroups");
+          const archive = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+          const entry = archive.find((item) => String(item.taskThreadId || item.id) === taskThreadId);
+          if (!entry) throw new Error("Archive entry not found: " + taskThreadId);
+          let changed = false;
+          if (input.title !== undefined) {
+            entry.title = String(input.title);
+            changed = true;
+          }
+          if (input.description !== undefined) {
+            entry.description = String(input.description);
+            changed = true;
+          }
+          if (input.status !== undefined) {
+            if (entry.locked) throw new Error("Cannot change status of a locked entry");
+            entry.status = coerceArchiveWorkflowStatusForWrite(input.status);
+            entry.statusUpdatedAt = now;
+            changed = true;
+          }
+          if (changed) entry.updatedAt = now;
+          await chrome.storage.local.set({ archivedGroups: archive });
+          return {
+            updated: true,
+            entityType: "archive",
+            taskThreadId,
+            audit: makeMetadataAudit({ entityType: "archive", taskThreadId })
+          };
+        }
+
+        if (entityType === "archive-tab") {
+          if (!taskThreadId) throw new Error("taskThreadId is required for archive tab metadata updates");
+          const tabIndex = Number(input.tabIndex);
+          if (!Number.isInteger(tabIndex) || tabIndex < 0) throw new Error("tabIndex is required");
+          const stored = await chrome.storage.local.get("archivedGroups");
+          const archive = Array.isArray(stored.archivedGroups) ? stored.archivedGroups : [];
+          const entry = archive.find((item) => String(item.taskThreadId || item.id) === taskThreadId);
+          if (!entry) throw new Error("Archive entry not found: " + taskThreadId);
+          entry.urls = Array.isArray(entry.urls) ? entry.urls : [];
+          if (!entry.urls[tabIndex]) throw new Error("Archive tab not found: " + tabIndex);
+          if (input.title !== undefined) entry.urls[tabIndex].title = String(input.title);
+          if (input.description !== undefined) entry.urls[tabIndex].description = String(input.description);
+          await chrome.storage.local.set({ archivedGroups: archive });
+          return {
+            updated: true,
+            entityType: "archive-tab",
+            taskThreadId,
+            tabIndex,
+            audit: makeMetadataAudit({ entityType: "archive-tab", taskThreadId, tabIndex })
+          };
+        }
+
+        const entityId = String(input.entityId || input.id || "");
+        if (!entityType || !entityId) throw new Error("entityType and entityId are required");
+        const stored = await chrome.storage.local.get("sessionEntityDescriptions");
+        const descriptions = stored.sessionEntityDescriptions || {};
+        const key = entityType + ":" + entityId;
+        descriptions[key] = {
+          entityType,
+          entityId,
+          description: String(input.description ?? ""),
+          updatedAt: now
+        };
+        await chrome.storage.local.set({ sessionEntityDescriptions: descriptions });
+        return {
+          updated: true,
+          entityType,
+          entityId,
+          audit: makeMetadataAudit({ entityType, entityId })
+        };
+      })()
+    `);
+    }
     /** Create a single tab and return its ID. Used by ETT restore_group. */
     async createTab(url, active = false) {
         return await this.evaluate(`

package/dist/window-bindings.d.ts

@@ -41,6 +41,13 @@ export interface CodexWindowBinding extends CodexSessionIdentity {
     status: CodexBindingStatus;
     createdAt: string;
     updatedAt: string;
+    /**
+     * ISO 8601 timestamp first recorded when a reap cycle found this binding's
+     * window absent from the live CDP set. Cleared when the window reappears.
+     * Drives the TTL grace period in {@link CodexWindowBindingStore.reapExpiredBindings}.
+     * Optional/absent on pre-existing records (backward-compatible).
+     */
+    missingSince?: string;
 }
 export interface RunBindingIndexEntry {
     runId: string;
@@ -72,6 +79,35 @@ export interface BindingMutationOptions {
     reason?: string;
     audit?: boolean;
 }
+/** Options for {@link CodexWindowBindingStore.reapExpiredBindings}. */
+export interface ReapOptions {
+    /** Distinct windowIds currently live in the browser (CDP). */
+    liveWindowIds: Iterable<number>;
+    /** Grace period in ms a binding may stay missing before it is reaped. */
+    ttlMs: number;
+    /** Injectable clock (ms epoch). Defaults to Date.now(). */
+    now?: number;
+    /**
+     * Archive callback invoked BEFORE a binding is deleted (e.g. recovery
+     * snapshot + ORPHAN_REAPED alert). If it throws, the binding is NOT deleted
+     * that cycle (fail-safe).
+     */
+    archive?: (binding: CodexWindowBinding) => Promise<void>;
+    /**
+     * Predicate for profile-owned bindings the auto-reaper must skip.
+     * Default: profileOwner is set and not "agent".
+     */
+    isProfileOwned?: (binding: CodexWindowBinding) => boolean;
+}
+/** Per-cycle counts returned by {@link CodexWindowBindingStore.reapExpiredBindings}. */
+export interface ReapCycleResult {
+    evaluated: number;
+    newlyMissing: number;
+    retainedLive: number;
+    reaped: number;
+    skippedOwned: number;
+    reapedBindingIds: string[];
+}
 export declare class WindowBindingConflictError extends Error {
     readonly conflicts: CodexWindowBinding[];
     constructor(message: string, conflicts: CodexWindowBinding[]);
@@ -105,6 +141,18 @@ export declare class CodexWindowBindingStore {
     transitionByRunId(runId: string, status: Exclude<CodexBindingStatus, "conflict">): Promise<CodexWindowBinding | null>;
     classifyConflicts(): Promise<CodexWindowBinding[]>;
     markStaleForMissingWindows(liveWindowIds: Iterable<number>): Promise<CodexWindowBinding[]>;
+    /**
+     * Reconcile every binding against the live window set and reap (delete) those
+     * whose window has been missing for at least {@link ReapOptions.ttlMs}.
+     *
+     * - Window live → clear `missingSince`, reactivate if the reaper marked it stale, retain.
+     * - Window missing, no `missingSince` → record `missingSince=now`, mark stale, retain (grace starts).
+     * - Window missing ≥ TTL, profile-owned → skip.
+     * - Window missing ≥ TTL, not owned → `archive()` then delete.
+     *
+     * Atomic + file-locked + idempotent. A no-op when nothing needs changing.
+     */
+    reapExpiredBindings(opts: ReapOptions): Promise<ReapCycleResult>;
     private assertNoActiveConflicts;
     private findActiveConflicts;
 }

package/dist/window-bindings.js

@@ -443,6 +443,91 @@ export class CodexWindowBindingStore {
             return stale;
         });
     }
+    /**
+     * Reconcile every binding against the live window set and reap (delete) those
+     * whose window has been missing for at least {@link ReapOptions.ttlMs}.
+     *
+     * - Window live → clear `missingSince`, reactivate if the reaper marked it stale, retain.
+     * - Window missing, no `missingSince` → record `missingSince=now`, mark stale, retain (grace starts).
+     * - Window missing ≥ TTL, profile-owned → skip.
+     * - Window missing ≥ TTL, not owned → `archive()` then delete.
+     *
+     * Atomic + file-locked + idempotent. A no-op when nothing needs changing.
+     */
+    async reapExpiredBindings(opts) {
+        const live = new Set(opts.liveWindowIds);
+        const now = opts.now ?? Date.now();
+        const ttlMs = opts.ttlMs;
+        const isOwned = opts.isProfileOwned ??
+            ((b) => b.profileOwner != null && b.profileOwner !== "agent");
+        const result = {
+            evaluated: 0,
+            newlyMissing: 0,
+            retainedLive: 0,
+            reaped: 0,
+            skippedOwned: 0,
+            reapedBindingIds: [],
+        };
+        return withFileLock(this.lockDir, async () => {
+            const snapshot = await readSnapshot(this.file);
+            let mutated = false;
+            const reapCandidates = [];
+            for (const binding of Object.values(snapshot.bindings)) {
+                result.evaluated += 1;
+                if (live.has(binding.windowId)) {
+                    if (binding.missingSince != null) {
+                        delete binding.missingSince;
+                        if (binding.status === "stale") {
+                            binding.status = "active";
+                        }
+                        binding.updatedAt = nowIso();
+                        mutated = true;
+                    }
+                    result.retainedLive += 1;
+                    continue;
+                }
+                // Window is missing from the live set.
+                if (binding.missingSince == null) {
+                    binding.missingSince = new Date(now).toISOString();
+                    binding.status = "stale";
+                    binding.updatedAt = nowIso();
+                    mutated = true;
+                    result.newlyMissing += 1;
+                    continue; // retained this cycle; grace period starts
+                }
+                const missingForMs = now - Date.parse(binding.missingSince);
+                if (!Number.isFinite(missingForMs) || missingForMs < ttlMs) {
+                    continue; // still within grace (or unparseable) → retain
+                }
+                if (isOwned(binding)) {
+                    result.skippedOwned += 1;
+                    continue;
+                }
+                reapCandidates.push(binding);
+            }
+            for (const binding of reapCandidates) {
+                if (opts.archive) {
+                    try {
+                        await opts.archive(binding);
+                    }
+                    catch {
+                        // Archive failed — do NOT delete (fail-safe, recoverable next cycle).
+                        continue;
+                    }
+                }
+                delete snapshot.bindings[binding.bindingId];
+                result.reaped += 1;
+                result.reapedBindingIds.push(binding.bindingId);
+                mutated = true;
+            }
+            if (mutated) {
+                snapshot.updatedAt = nowIso();
+                snapshot.runBindingIndex = rebuildRunBindingIndex(snapshot.bindings);
+                await writeSnapshot(this.file, this.dir, snapshot);
+            }
+            return result;
+        });
+    }
     assertNoActiveConflicts(snapshot) {
         const conflicts = this.findActiveConflicts(snapshot);
         if (conflicts.length > 0) {

package/extension/background.js

@@ -486,7 +486,7 @@ chrome.action.onClicked.addListener(async (tab) => {
       })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
       // Spec 037: Orchestrator session data
       orchestratorUrl: sessionData?.orchestratorUrl || null,
       taskGoal: sessionData?.taskGoal || null,
@@ -594,6 +594,27 @@ function normalizeInstructionText(value) {
   return value === undefined || value === null ? "" : String(value).trim();
 }
 
+function normalizeArchiveWorkflowStatus(status) {
+  if (globalThis.SessionLogic?.normalizeArchiveWorkflowStatus) {
+    return globalThis.SessionLogic.normalizeArchiveWorkflowStatus(status);
+  }
+  const raw = String(status || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "done") return "done";
+  if (raw === "trashed") return "trashed";
+  return "pending";
+}
+
+function coerceArchiveWorkflowStatusForWrite(status) {
+  const raw = String(status || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "saved" || raw === "archived") return "pending";
+  if (raw === "pending" || raw === "done" || raw === "trashed") return raw;
+  throw new Error(`Invalid status: ${status}`);
+}
+
 function hasOwn(record, key) {
   return !!record && Object.prototype.hasOwnProperty.call(record, key);
 }
@@ -666,6 +687,7 @@ function normalizeArchiveEntry(entry) {
   normalized.urls = Array.isArray(normalized.urls)
     ? normalized.urls.map((tab) => normalizeArchiveTab(tab, normalized.description))
     : [];
+  normalized.status = normalizeArchiveWorkflowStatus(normalized.status);
   return normalized;
 }
 
@@ -743,7 +765,7 @@ async function buildArchiveEntryFromLiveGroup(groupId, title, snapshotOnly = fal
     })),
     archivedAt: new Date().toISOString(),
     restoredAt: null,
-    status: "archived",
+    status: "pending",
     sourceWindowId: windowId,
     sourceDisplayId,
     starred: false,
@@ -912,7 +934,7 @@ registerHandler("restoreGroup", async ({ taskThreadId, target = "newWindow", sou
   // Update archive entry status
   archive[idx] = {
     ...entry,
-    status: "saved",
+    status: "pending",
     restoredAt: new Date().toISOString(),
   };
   await saveArchive(archive);
@@ -1056,15 +1078,14 @@ registerHandler("updateArchiveDescription", async ({ taskThreadId, description }
   return { description: entry.description };
 });
 
-// T052: Update status (archived, pending, trashed)
+// T052: Update workflow status (pending, done, trashed; legacy aliases saved/archived)
 registerHandler("updateArchiveStatus", async ({ taskThreadId, status }) => {
-  const valid = ["saved", "archived", "pending", "done", "trashed"];
-  if (!valid.includes(status)) throw new Error(`Invalid status: ${status}`);
+  const nextStatus = coerceArchiveWorkflowStatusForWrite(status);
   const archive = await loadArchive();
   const entry = archive.find((e) => e.taskThreadId === taskThreadId);
   if (!entry) throw new Error(`Not found: ${taskThreadId}`);
   if (entry.locked) throw new Error("Cannot change status of a locked entry");
-  entry.status = status;
+  entry.status = nextStatus;
   await saveArchive(archive);
   return { status: entry.status };
 });
@@ -1218,7 +1239,7 @@ registerHandler("saveAllTabs", async () => {
       }),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
     };
     archive.unshift(entry);
     archivedCount++;
@@ -1243,7 +1264,7 @@ registerHandler("saveAllTabs", async () => {
       })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
     };
     archive.unshift(entry);
     archivedCount++;
@@ -1386,7 +1407,7 @@ registerHandler("importUrls", async ({ groups }) => {
       })),
       archivedAt: new Date().toISOString(),
       restoredAt: null,
-      status: "archived",
+      status: "pending",
     };
     archive.unshift(entry);
     imported += entry.urls.length;
@@ -1767,7 +1788,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: [{ url: tab.url || "", title: tab.title || "" }],
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
         // If tab is in a group, use the group name
         if (tab.groupId && tab.groupId !== -1) {
@@ -1817,7 +1838,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
             urls: tabs.map((t) => ({ url: t.url || "", title: t.title || "" })),
             archivedAt: new Date().toISOString(),
             restoredAt: null,
-            status: "archived",
+            status: "pending",
           };
           archive.unshift(entry);
         }
@@ -1856,7 +1877,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: eligible.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
 
         const archive = await loadArchive();
@@ -1883,7 +1904,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: eligible.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
 
         const archive = await loadArchive();
@@ -1921,7 +1942,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
 
         const archive = await loadArchive();
@@ -1950,7 +1971,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
 
         const archive = await loadArchive();
@@ -1979,7 +2000,7 @@ chrome.contextMenus.onClicked.addListener(async (info, tab) => {
           urls: toArchive.map((t) => ({ url: t.url || "", title: t.title || "" })),
           archivedAt: new Date().toISOString(),
           restoredAt: null,
-          status: "archived",
+          status: "pending",
         };
 
         const archive = await loadArchive();

package/extension/manifest.json

@@ -6,6 +6,7 @@
   "permissions": [
     "tabGroups",
     "tabs",
+    "activeTab",
     "alarms",
     "sidePanel",
     "sessions",
@@ -13,9 +14,14 @@
     "contextMenus",
     "system.display",
     "scripting",
-    "bookmarks"
+    "bookmarks",
+    "debugger",
+    "webNavigation"
   ],
   "host_permissions": [
+    "https://perplexity.ai/*",
+    "https://*.perplexity.ai/*",
+    "https://comet.perplexity.ai/*",
     "http://localhost/*",
     "http://127.0.0.1/*",
     "http://localhost:11434/*",
@@ -27,6 +33,15 @@
     "128": "icons/icon128.png"
   },
   "action": {},
+  "commands": {
+    "_execute_action": {
+      "suggested_key": {
+        "default": "Ctrl+Shift+Y",
+        "mac": "Command+Shift+Y"
+      },
+      "description": "Open Equabotz Browser Agents"
+    }
+  },
   "background": {
     "service_worker": "background.js"
   },