@flrande/bak-extension 0.2.5 → 0.3.1

package/dist/background.global.js

@@ -30,11 +30,560 @@
     return Math.min(maxDelayMs, baseDelayMs * 2 ** safeAttempt);
   }
 
+  // src/workspace.ts
+  var DEFAULT_WORKSPACE_ID = "default";
+  var DEFAULT_WORKSPACE_LABEL = "bak agent";
+  var DEFAULT_WORKSPACE_COLOR = "blue";
+  var DEFAULT_WORKSPACE_URL = "about:blank";
+  var WorkspaceManager = class {
+    storage;
+    browser;
+    constructor(storage, browser) {
+      this.storage = storage;
+      this.browser = browser;
+    }
+    async getWorkspaceInfo(workspaceId = DEFAULT_WORKSPACE_ID) {
+      return this.inspectWorkspace(workspaceId);
+    }
+    async ensureWorkspace(options = {}) {
+      const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
+      const repairActions = [];
+      const initialUrl = options.initialUrl ?? DEFAULT_WORKSPACE_URL;
+      const persisted = await this.storage.load();
+      const created = !persisted;
+      let state = this.normalizeState(persisted, workspaceId);
+      let window = state.windowId !== null ? await this.waitForWindow(state.windowId) : null;
+      let tabs = [];
+      if (!window) {
+        const createdWindow = await this.browser.createWindow({
+          url: initialUrl,
+          focused: options.focus === true
+        });
+        state.windowId = createdWindow.id;
+        state.groupId = null;
+        state.tabIds = [];
+        state.activeTabId = null;
+        state.primaryTabId = null;
+        window = createdWindow;
+        tabs = await this.waitForWindowTabs(createdWindow.id);
+        state.tabIds = tabs.map((tab) => tab.id);
+        if (state.primaryTabId === null) {
+          state.primaryTabId = tabs[0]?.id ?? null;
+        }
+        if (state.activeTabId === null) {
+          state.activeTabId = tabs.find((tab) => tab.active)?.id ?? tabs[0]?.id ?? null;
+        }
+        repairActions.push(created ? "created-window" : "recreated-window");
+      }
+      tabs = tabs.length > 0 ? tabs : await this.readTrackedTabs(state.tabIds, state.windowId);
+      const recoveredTabs = await this.recoverWorkspaceTabs(state, tabs);
+      if (recoveredTabs.length > tabs.length) {
+        tabs = recoveredTabs;
+        repairActions.push("recovered-tracked-tabs");
+      }
+      if (tabs.length !== state.tabIds.length) {
+        repairActions.push("pruned-missing-tabs");
+      }
+      state.tabIds = tabs.map((tab) => tab.id);
+      if (tabs.length === 0) {
+        const primary = await this.createWorkspaceTab({
+          windowId: state.windowId,
+          url: initialUrl,
+          active: true
+        });
+        tabs = [primary];
+        state.tabIds = [primary.id];
+        state.primaryTabId = primary.id;
+        state.activeTabId = primary.id;
+        repairActions.push("created-primary-tab");
+      }
+      if (state.primaryTabId === null || !tabs.some((tab) => tab.id === state.primaryTabId)) {
+        state.primaryTabId = tabs[0]?.id ?? null;
+        repairActions.push("reassigned-primary-tab");
+      }
+      if (state.activeTabId === null || !tabs.some((tab) => tab.id === state.activeTabId)) {
+        state.activeTabId = state.primaryTabId ?? tabs[0]?.id ?? null;
+        repairActions.push("reassigned-active-tab");
+      }
+      let group = state.groupId !== null ? await this.browser.getGroup(state.groupId) : null;
+      if (!group || group.windowId !== state.windowId) {
+        const groupId = await this.browser.groupTabs(tabs.map((tab) => tab.id));
+        group = await this.browser.updateGroup(groupId, {
+          title: state.label,
+          color: state.color,
+          collapsed: false
+        });
+        state.groupId = group.id;
+        repairActions.push("recreated-group");
+      } else {
+        await this.browser.updateGroup(group.id, {
+          title: state.label,
+          color: state.color,
+          collapsed: false
+        });
+      }
+      const ungroupedIds = tabs.filter((tab) => tab.groupId !== state.groupId).map((tab) => tab.id);
+      if (ungroupedIds.length > 0) {
+        await this.browser.groupTabs(ungroupedIds, state.groupId ?? void 0);
+        repairActions.push("regrouped-tabs");
+      }
+      tabs = await this.readTrackedTabs(state.tabIds, state.windowId);
+      tabs = await this.recoverWorkspaceTabs(state, tabs);
+      const activeTab = state.activeTabId !== null ? await this.waitForTrackedTab(state.activeTabId, state.windowId) : null;
+      if (activeTab && !tabs.some((tab) => tab.id === activeTab.id)) {
+        tabs = [...tabs, activeTab];
+      }
+      if (tabs.length === 0 && state.primaryTabId !== null) {
+        const primaryTab = await this.waitForTrackedTab(state.primaryTabId, state.windowId);
+        if (primaryTab) {
+          tabs = [primaryTab];
+        }
+      }
+      state.tabIds = [...new Set(tabs.map((tab) => tab.id))];
+      if (options.focus === true && state.activeTabId !== null) {
+        await this.browser.updateTab(state.activeTabId, { active: true });
+        window = await this.browser.updateWindow(state.windowId, { focused: true });
+        void window;
+        repairActions.push("focused-window");
+      }
+      await this.storage.save(state);
+      return {
+        workspace: {
+          ...state,
+          tabs
+        },
+        created,
+        repaired: repairActions.length > 0,
+        repairActions
+      };
+    }
+    async openTab(options = {}) {
+      const ensured = await this.ensureWorkspace({
+        workspaceId: options.workspaceId,
+        focus: false,
+        initialUrl: options.url ?? DEFAULT_WORKSPACE_URL
+      });
+      let state = { ...ensured.workspace };
+      const active = options.active === true;
+      const desiredUrl = options.url ?? DEFAULT_WORKSPACE_URL;
+      let reusablePrimaryTab = await this.resolveReusablePrimaryTab(
+        state,
+        ensured.created || ensured.repairActions.includes("recreated-window") || ensured.repairActions.includes("created-primary-tab")
+      );
+      let createdTab;
+      try {
+        createdTab = reusablePrimaryTab ? await this.browser.updateTab(reusablePrimaryTab.id, {
+          url: desiredUrl,
+          active
+        }) : await this.createWorkspaceTab({
+          windowId: state.windowId,
+          url: desiredUrl,
+          active
+        });
+      } catch (error) {
+        if (!this.isMissingWindowError(error)) {
+          throw error;
+        }
+        const repaired = await this.ensureWorkspace({
+          workspaceId: options.workspaceId,
+          focus: false,
+          initialUrl: desiredUrl
+        });
+        state = { ...repaired.workspace };
+        reusablePrimaryTab = await this.resolveReusablePrimaryTab(state, true);
+        createdTab = reusablePrimaryTab ? await this.browser.updateTab(reusablePrimaryTab.id, {
+          url: desiredUrl,
+          active
+        }) : await this.createWorkspaceTab({
+          windowId: state.windowId,
+          url: desiredUrl,
+          active
+        });
+      }
+      const nextTabIds = [.../* @__PURE__ */ new Set([...state.tabIds, createdTab.id])];
+      const groupId = await this.browser.groupTabs([createdTab.id], state.groupId ?? void 0);
+      await this.browser.updateGroup(groupId, {
+        title: state.label,
+        color: state.color,
+        collapsed: false
+      });
+      const nextState = {
+        id: state.id,
+        label: state.label,
+        color: state.color,
+        windowId: state.windowId,
+        groupId,
+        tabIds: nextTabIds,
+        activeTabId: createdTab.id,
+        primaryTabId: state.primaryTabId ?? createdTab.id
+      };
+      if (options.focus === true) {
+        await this.browser.updateTab(createdTab.id, { active: true });
+        await this.browser.updateWindow(state.windowId, { focused: true });
+      }
+      await this.storage.save(nextState);
+      const tabs = await this.readTrackedTabs(nextState.tabIds, nextState.windowId);
+      const tab = tabs.find((item) => item.id === createdTab.id) ?? createdTab;
+      return {
+        workspace: {
+          ...nextState,
+          tabs
+        },
+        tab
+      };
+    }
+    async listTabs(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const ensured = await this.inspectWorkspace(workspaceId);
+      if (!ensured) {
+        throw new Error(`Workspace ${workspaceId} does not exist`);
+      }
+      return {
+        workspace: ensured,
+        tabs: ensured.tabs
+      };
+    }
+    async getActiveTab(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const ensured = await this.inspectWorkspace(workspaceId);
+      if (!ensured) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        return {
+          workspace: {
+            ...this.normalizeState(null, normalizedWorkspaceId),
+            tabs: []
+          },
+          tab: null
+        };
+      }
+      return {
+        workspace: ensured,
+        tab: ensured.tabs.find((tab) => tab.id === ensured.activeTabId) ?? null
+      };
+    }
+    async setActiveTab(tabId, workspaceId = DEFAULT_WORKSPACE_ID) {
+      const ensured = await this.ensureWorkspace({ workspaceId });
+      if (!ensured.workspace.tabIds.includes(tabId)) {
+        throw new Error(`Tab ${tabId} does not belong to workspace ${workspaceId}`);
+      }
+      const nextState = {
+        id: ensured.workspace.id,
+        label: ensured.workspace.label,
+        color: ensured.workspace.color,
+        windowId: ensured.workspace.windowId,
+        groupId: ensured.workspace.groupId,
+        tabIds: [...ensured.workspace.tabIds],
+        activeTabId: tabId,
+        primaryTabId: ensured.workspace.primaryTabId ?? tabId
+      };
+      await this.storage.save(nextState);
+      const tabs = await this.readTrackedTabs(nextState.tabIds, nextState.windowId);
+      const tab = tabs.find((item) => item.id === tabId);
+      if (!tab) {
+        throw new Error(`Tab ${tabId} is missing from workspace ${workspaceId}`);
+      }
+      return {
+        workspace: {
+          ...nextState,
+          tabs
+        },
+        tab
+      };
+    }
+    async focus(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const ensured = await this.ensureWorkspace({ workspaceId, focus: false });
+      if (ensured.workspace.activeTabId !== null) {
+        await this.browser.updateTab(ensured.workspace.activeTabId, { active: true });
+      }
+      if (ensured.workspace.windowId !== null) {
+        await this.browser.updateWindow(ensured.workspace.windowId, { focused: true });
+      }
+      const refreshed = await this.ensureWorkspace({ workspaceId, focus: false });
+      return { ok: true, workspace: refreshed.workspace };
+    }
+    async reset(options = {}) {
+      await this.close(options.workspaceId);
+      return this.ensureWorkspace(options);
+    }
+    async close(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const state = await this.storage.load();
+      if (!state || state.id !== workspaceId) {
+        await this.storage.save(null);
+        return { ok: true };
+      }
+      if (state.windowId !== null) {
+        const existingWindow = await this.browser.getWindow(state.windowId);
+        if (existingWindow) {
+          await this.browser.closeWindow(state.windowId);
+        }
+      }
+      await this.storage.save(null);
+      return { ok: true };
+    }
+    async resolveTarget(options = {}) {
+      if (typeof options.tabId === "number") {
+        const explicitTab = await this.browser.getTab(options.tabId);
+        if (!explicitTab) {
+          throw new Error(`No tab with id ${options.tabId}`);
+        }
+        return {
+          tab: explicitTab,
+          workspace: null,
+          resolution: "explicit-tab",
+          createdWorkspace: false,
+          repaired: false,
+          repairActions: []
+        };
+      }
+      const explicitWorkspaceId = typeof options.workspaceId === "string" ? this.normalizeWorkspaceId(options.workspaceId) : void 0;
+      if (explicitWorkspaceId) {
+        const ensured2 = await this.ensureWorkspace({
+          workspaceId: explicitWorkspaceId,
+          focus: false
+        });
+        return this.buildWorkspaceResolution(ensured2, "explicit-workspace");
+      }
+      const existingWorkspace = await this.loadWorkspaceRecord(DEFAULT_WORKSPACE_ID);
+      if (existingWorkspace) {
+        const ensured2 = await this.ensureWorkspace({
+          workspaceId: existingWorkspace.id,
+          focus: false
+        });
+        return this.buildWorkspaceResolution(ensured2, "default-workspace");
+      }
+      if (options.createIfMissing !== true) {
+        const activeTab = await this.browser.getActiveTab();
+        if (!activeTab) {
+          throw new Error("No active tab");
+        }
+        return {
+          tab: activeTab,
+          workspace: null,
+          resolution: "browser-active",
+          createdWorkspace: false,
+          repaired: false,
+          repairActions: []
+        };
+      }
+      const ensured = await this.ensureWorkspace({
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        focus: false
+      });
+      return this.buildWorkspaceResolution(ensured, "default-workspace");
+    }
+    normalizeWorkspaceId(workspaceId) {
+      const candidate = workspaceId?.trim();
+      if (!candidate) {
+        return DEFAULT_WORKSPACE_ID;
+      }
+      if (candidate !== DEFAULT_WORKSPACE_ID) {
+        throw new Error(`Unsupported workspace id: ${candidate}`);
+      }
+      return candidate;
+    }
+    normalizeState(state, workspaceId) {
+      return {
+        id: workspaceId,
+        label: state?.label ?? DEFAULT_WORKSPACE_LABEL,
+        color: state?.color ?? DEFAULT_WORKSPACE_COLOR,
+        windowId: state?.windowId ?? null,
+        groupId: state?.groupId ?? null,
+        tabIds: state?.tabIds ?? [],
+        activeTabId: state?.activeTabId ?? null,
+        primaryTabId: state?.primaryTabId ?? null
+      };
+    }
+    async loadWorkspaceRecord(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+      const state = await this.storage.load();
+      if (!state || state.id !== normalizedWorkspaceId) {
+        return null;
+      }
+      return this.normalizeState(state, normalizedWorkspaceId);
+    }
+    async buildWorkspaceResolution(ensured, resolution) {
+      const tab = ensured.workspace.tabs.find((item) => item.id === ensured.workspace.activeTabId) ?? ensured.workspace.tabs[0] ?? null;
+      if (tab) {
+        return {
+          tab,
+          workspace: ensured.workspace,
+          resolution,
+          createdWorkspace: ensured.created,
+          repaired: ensured.repaired,
+          repairActions: ensured.repairActions
+        };
+      }
+      if (ensured.workspace.activeTabId !== null) {
+        const activeWorkspaceTab = await this.waitForTrackedTab(ensured.workspace.activeTabId, ensured.workspace.windowId);
+        if (activeWorkspaceTab) {
+          return {
+            tab: activeWorkspaceTab,
+            workspace: ensured.workspace,
+            resolution,
+            createdWorkspace: ensured.created,
+            repaired: ensured.repaired,
+            repairActions: ensured.repairActions
+          };
+        }
+      }
+      const activeTab = await this.browser.getActiveTab();
+      if (!activeTab) {
+        throw new Error("No active tab");
+      }
+      return {
+        tab: activeTab,
+        workspace: null,
+        resolution: "browser-active",
+        createdWorkspace: ensured.created,
+        repaired: ensured.repaired,
+        repairActions: ensured.repairActions
+      };
+    }
+    async readTrackedTabs(tabIds, windowId) {
+      const tabs = (await Promise.all(
+        tabIds.map(async (tabId) => {
+          const tab = await this.browser.getTab(tabId);
+          if (!tab) {
+            return null;
+          }
+          if (windowId !== null && tab.windowId !== windowId) {
+            return null;
+          }
+          return tab;
+        })
+      )).filter((tab) => tab !== null);
+      return tabs;
+    }
+    async recoverWorkspaceTabs(state, existingTabs) {
+      if (state.windowId === null) {
+        return existingTabs;
+      }
+      const candidates = await this.waitForWindowTabs(state.windowId, 500);
+      if (candidates.length === 0) {
+        return existingTabs;
+      }
+      const trackedIds = new Set(state.tabIds);
+      const trackedTabs = candidates.filter((tab) => trackedIds.has(tab.id));
+      if (trackedTabs.length > existingTabs.length) {
+        return trackedTabs;
+      }
+      if (state.groupId !== null) {
+        const groupedTabs = candidates.filter((tab) => tab.groupId === state.groupId);
+        if (groupedTabs.length > 0) {
+          return groupedTabs;
+        }
+      }
+      const preferredIds = new Set([state.activeTabId, state.primaryTabId].filter((value) => typeof value === "number"));
+      const preferredTabs = candidates.filter((tab) => preferredIds.has(tab.id));
+      if (preferredTabs.length > existingTabs.length) {
+        return preferredTabs;
+      }
+      return existingTabs;
+    }
+    async createWorkspaceTab(options) {
+      if (options.windowId === null) {
+        throw new Error("Workspace window is unavailable");
+      }
+      const deadline = Date.now() + 1500;
+      let lastError2 = null;
+      while (Date.now() < deadline) {
+        try {
+          return await this.browser.createTab({
+            windowId: options.windowId,
+            url: options.url,
+            active: options.active
+          });
+        } catch (error) {
+          if (!this.isMissingWindowError(error)) {
+            throw error;
+          }
+          lastError2 = error instanceof Error ? error : new Error(String(error));
+          await this.delay(50);
+        }
+      }
+      throw lastError2 ?? new Error(`No window with id: ${options.windowId}.`);
+    }
+    async inspectWorkspace(workspaceId = DEFAULT_WORKSPACE_ID) {
+      const state = await this.loadWorkspaceRecord(workspaceId);
+      if (!state) {
+        return null;
+      }
+      let tabs = await this.readTrackedTabs(state.tabIds, state.windowId);
+      const activeTab = state.activeTabId !== null ? await this.waitForTrackedTab(state.activeTabId, state.windowId, 300) : null;
+      if (activeTab && !tabs.some((tab) => tab.id === activeTab.id)) {
+        tabs = [...tabs, activeTab];
+      }
+      if (tabs.length === 0 && state.primaryTabId !== null) {
+        const primaryTab = await this.waitForTrackedTab(state.primaryTabId, state.windowId, 300);
+        if (primaryTab) {
+          tabs = [primaryTab];
+        }
+      }
+      return {
+        ...state,
+        tabIds: [...new Set(state.tabIds.concat(tabs.map((tab) => tab.id)))],
+        tabs
+      };
+    }
+    async resolveReusablePrimaryTab(workspace, allowReuse) {
+      if (!allowReuse || workspace.windowId === null) {
+        return null;
+      }
+      if (workspace.primaryTabId !== null) {
+        const trackedPrimary = workspace.tabs.find((tab) => tab.id === workspace.primaryTabId) ?? await this.waitForTrackedTab(workspace.primaryTabId, workspace.windowId);
+        if (trackedPrimary) {
+          return trackedPrimary;
+        }
+      }
+      const windowTabs = await this.waitForWindowTabs(workspace.windowId, 750);
+      return windowTabs.length === 1 ? windowTabs[0] : null;
+    }
+    async waitForWindow(windowId, timeoutMs = 750) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const window = await this.browser.getWindow(windowId);
+        if (window) {
+          return window;
+        }
+        await this.delay(50);
+      }
+      return null;
+    }
+    async waitForTrackedTab(tabId, windowId, timeoutMs = 1e3) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const tab = await this.browser.getTab(tabId);
+        if (tab && (windowId === null || tab.windowId === windowId)) {
+          return tab;
+        }
+        await this.delay(50);
+      }
+      return null;
+    }
+    async waitForWindowTabs(windowId, timeoutMs = 1e3) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const tabs = await this.browser.listTabs({ windowId });
+        if (tabs.length > 0) {
+          return tabs;
+        }
+        await this.delay(50);
+      }
+      return [];
+    }
+    async delay(ms) {
+      await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    isMissingWindowError(error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return message.toLowerCase().includes("no window with id");
+    }
+  };
+
   // src/background.ts
   var DEFAULT_PORT = 17373;
   var STORAGE_KEY_TOKEN = "pairToken";
   var STORAGE_KEY_PORT = "cliPort";
   var STORAGE_KEY_DEBUG_RICH_TEXT = "debugRichText";
+  var STORAGE_KEY_WORKSPACE = "agentWorkspace";
   var DEFAULT_TAB_LOAD_TIMEOUT_MS = 4e4;
   var ws = null;
   var reconnectTimer = null;
@@ -104,6 +653,171 @@
     }
     return toError("E_INTERNAL", message);
   }
+  function toTabInfo(tab) {
+    if (typeof tab.id !== "number" || typeof tab.windowId !== "number") {
+      throw new Error("Tab is missing runtime identifiers");
+    }
+    return {
+      id: tab.id,
+      title: tab.title ?? "",
+      url: tab.url ?? "",
+      active: Boolean(tab.active),
+      windowId: tab.windowId,
+      groupId: typeof tab.groupId === "number" && tab.groupId >= 0 ? tab.groupId : null
+    };
+  }
+  async function loadWorkspaceState() {
+    const stored = await chrome.storage.local.get(STORAGE_KEY_WORKSPACE);
+    const state = stored[STORAGE_KEY_WORKSPACE];
+    if (!state || typeof state !== "object") {
+      return null;
+    }
+    return state;
+  }
+  async function saveWorkspaceState(state) {
+    if (state === null) {
+      await chrome.storage.local.remove(STORAGE_KEY_WORKSPACE);
+      return;
+    }
+    await chrome.storage.local.set({ [STORAGE_KEY_WORKSPACE]: state });
+  }
+  var workspaceBrowser = {
+    async getTab(tabId) {
+      try {
+        return toTabInfo(await chrome.tabs.get(tabId));
+      } catch {
+        return null;
+      }
+    },
+    async getActiveTab() {
+      const tabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+      const tab = tabs[0];
+      if (!tab) {
+        return null;
+      }
+      return toTabInfo(tab);
+    },
+    async listTabs(filter) {
+      const tabs = await chrome.tabs.query(filter?.windowId ? { windowId: filter.windowId } : {});
+      return tabs.filter((tab) => typeof tab.id === "number" && typeof tab.windowId === "number").map((tab) => toTabInfo(tab));
+    },
+    async createTab(options) {
+      const createdTab = await chrome.tabs.create({
+        windowId: options.windowId,
+        url: options.url ?? "about:blank",
+        active: options.active
+      });
+      if (!createdTab) {
+        throw new Error("Tab creation returned no tab");
+      }
+      return toTabInfo(createdTab);
+    },
+    async updateTab(tabId, options) {
+      const updatedTab = await chrome.tabs.update(tabId, {
+        active: options.active,
+        url: options.url
+      });
+      if (!updatedTab) {
+        throw new Error(`Tab update returned no tab for ${tabId}`);
+      }
+      return toTabInfo(updatedTab);
+    },
+    async closeTab(tabId) {
+      await chrome.tabs.remove(tabId);
+    },
+    async getWindow(windowId) {
+      try {
+        const window = await chrome.windows.get(windowId);
+        return {
+          id: window.id,
+          focused: Boolean(window.focused)
+        };
+      } catch {
+        return null;
+      }
+    },
+    async createWindow(options) {
+      const previouslyFocusedWindow = options.focused === true ? null : (await chrome.windows.getAll()).find((window) => window.focused === true && typeof window.id === "number") ?? null;
+      const previouslyFocusedTab = previouslyFocusedWindow?.id !== void 0 ? (await chrome.tabs.query({ windowId: previouslyFocusedWindow.id, active: true })).find((tab) => typeof tab.id === "number") ?? null : null;
+      const created = await chrome.windows.create({
+        url: options.url ?? "about:blank",
+        focused: true
+      });
+      if (!created || typeof created.id !== "number") {
+        throw new Error("Window missing id");
+      }
+      if (options.focused !== true && previouslyFocusedWindow?.id && previouslyFocusedWindow.id !== created.id) {
+        await chrome.windows.update(previouslyFocusedWindow.id, { focused: true });
+        if (typeof previouslyFocusedTab?.id === "number") {
+          await chrome.tabs.update(previouslyFocusedTab.id, { active: true });
+        }
+      }
+      const finalWindow = await chrome.windows.get(created.id);
+      return {
+        id: finalWindow.id,
+        focused: Boolean(finalWindow.focused)
+      };
+    },
+    async updateWindow(windowId, options) {
+      const updated = await chrome.windows.update(windowId, {
+        focused: options.focused
+      });
+      if (!updated || typeof updated.id !== "number") {
+        throw new Error("Window missing id");
+      }
+      return {
+        id: updated.id,
+        focused: Boolean(updated.focused)
+      };
+    },
+    async closeWindow(windowId) {
+      await chrome.windows.remove(windowId);
+    },
+    async getGroup(groupId) {
+      try {
+        const group = await chrome.tabGroups.get(groupId);
+        return {
+          id: group.id,
+          windowId: group.windowId,
+          title: group.title ?? "",
+          color: group.color,
+          collapsed: Boolean(group.collapsed)
+        };
+      } catch {
+        return null;
+      }
+    },
+    async groupTabs(tabIds, groupId) {
+      return await chrome.tabs.group({
+        tabIds,
+        groupId
+      });
+    },
+    async updateGroup(groupId, options) {
+      const updated = await chrome.tabGroups.update(groupId, {
+        title: options.title,
+        color: options.color,
+        collapsed: options.collapsed
+      });
+      if (!updated) {
+        throw new Error(`Tab group update returned no group for ${groupId}`);
+      }
+      return {
+        id: updated.id,
+        windowId: updated.windowId,
+        title: updated.title ?? "",
+        color: updated.color,
+        collapsed: Boolean(updated.collapsed)
+      };
+    }
+  };
+  var workspaceManager = new WorkspaceManager(
+    {
+      load: loadWorkspaceState,
+      save: saveWorkspaceState
+    },
+    workspaceBrowser
+  );
   async function waitForTabComplete(tabId, timeoutMs = DEFAULT_TAB_LOAD_TIMEOUT_MS) {
     try {
       const current = await chrome.tabs.get(tabId);
@@ -161,28 +875,46 @@
       probeStatus();
     });
   }
-  async function withTab(tabId, options = {}) {
+  async function waitForTabUrl(tabId, expectedUrl, timeoutMs = 1e4) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try {
+        const tab = await chrome.tabs.get(tabId);
+        const currentUrl = tab.url ?? "";
+        const pendingUrl = "pendingUrl" in tab && typeof tab.pendingUrl === "string" ? tab.pendingUrl : "";
+        if (currentUrl === expectedUrl || pendingUrl === expectedUrl) {
+          return;
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`tab url timeout: ${tabId} -> ${expectedUrl}`);
+  }
+  async function withTab(target = {}, options = {}) {
     const requireSupportedAutomationUrl = options.requireSupportedAutomationUrl !== false;
     const validate = (tab2) => {
       if (!tab2.id) {
         throw toError("E_NOT_FOUND", "Tab missing id");
       }
-      if (requireSupportedAutomationUrl && !isSupportedAutomationUrl(tab2.url)) {
+      const pendingUrl = "pendingUrl" in tab2 && typeof tab2.pendingUrl === "string" ? tab2.pendingUrl : "";
+      if (requireSupportedAutomationUrl && !isSupportedAutomationUrl(tab2.url) && !isSupportedAutomationUrl(pendingUrl)) {
         throw toError("E_PERMISSION", "Unsupported tab URL: only http/https pages can be automated", {
-          url: tab2.url ?? ""
+          url: tab2.url ?? pendingUrl ?? ""
         });
       }
       return tab2;
     };
-    if (typeof tabId === "number") {
-      const tab2 = await chrome.tabs.get(tabId);
+    if (typeof target.tabId === "number") {
+      const tab2 = await chrome.tabs.get(target.tabId);
       return validate(tab2);
     }
-    const tabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
-    const tab = tabs[0];
-    if (!tab) {
-      throw toError("E_NOT_FOUND", "No active tab");
-    }
+    const resolved = await workspaceManager.resolveTarget({
+      tabId: target.tabId,
+      workspaceId: typeof target.workspaceId === "string" ? target.workspaceId : void 0,
+      createIfMissing: false
+    });
+    const tab = await chrome.tabs.get(resolved.tab.id);
     return validate(tab);
   }
   async function captureAlignedTabScreenshot(tab) {
@@ -208,7 +940,7 @@
     }
   }
   async function sendToContent(tabId, message) {
-    const maxAttempts = 6;
+    const maxAttempts = 10;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
       try {
         const response = await chrome.tabs.sendMessage(tabId, message);
@@ -222,11 +954,44 @@
         if (!retriable || attempt >= maxAttempts) {
           throw toError("E_NOT_READY", "Content script unavailable", { detail });
         }
-        await new Promise((resolve) => setTimeout(resolve, 150 * attempt));
+        await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
       }
     }
     throw toError("E_NOT_READY", "Content script unavailable");
   }
+  async function captureFocusContext() {
+    const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+    const activeTab = activeTabs.find((tab) => typeof tab.id === "number" && typeof tab.windowId === "number") ?? null;
+    return {
+      windowId: activeTab?.windowId ?? null,
+      tabId: activeTab?.id ?? null
+    };
+  }
+  async function restoreFocusContext(context) {
+    if (context.windowId !== null) {
+      try {
+        await chrome.windows.update(context.windowId, { focused: true });
+      } catch {
+      }
+    }
+    if (context.tabId !== null) {
+      try {
+        await chrome.tabs.update(context.tabId, { active: true });
+      } catch {
+      }
+    }
+  }
+  async function preserveHumanFocus(enabled, action) {
+    if (!enabled) {
+      return action();
+    }
+    const focusContext = await captureFocusContext();
+    try {
+      return await action();
+    } finally {
+      await restoreFocusContext(focusContext);
+    }
+  }
   function requireRpcEnvelope(method, value) {
     if (typeof value !== "object" || value === null || typeof value.ok !== "boolean") {
       throw toError("E_NOT_READY", `Content script returned malformed response for ${method}`);
@@ -247,6 +1012,10 @@
   }
   async function handleRequest(request) {
     const params = request.params ?? {};
+    const target = {
+      tabId: typeof params.tabId === "number" ? params.tabId : void 0,
+      workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0
+    };
     const rpcForwardMethods = /* @__PURE__ */ new Set([
       "page.title",
       "page.url",
@@ -291,12 +1060,7 @@
       case "tabs.list": {
         const tabs = await chrome.tabs.query({});
         return {
-          tabs: tabs.filter((tab) => typeof tab.id === "number").map((tab) => ({
-            id: tab.id,
-            title: tab.title ?? "",
-            url: tab.url ?? "",
-            active: tab.active
-          }))
+          tabs: tabs.filter((tab) => typeof tab.id === "number" && typeof tab.windowId === "number").map((tab) => toTabInfo(tab))
         };
       }
       case "tabs.getActive": {
@@ -306,12 +1070,7 @@
           return { tab: null };
         }
         return {
-          tab: {
-            id: tab.id,
-            title: tab.title ?? "",
-            url: tab.url ?? "",
-            active: Boolean(tab.active)
-          }
+          tab: toTabInfo(tab)
         };
       }
       case "tabs.get": {
@@ -321,12 +1080,7 @@
           throw toError("E_NOT_FOUND", "Tab missing id");
         }
         return {
-          tab: {
-            id: tab.id,
-            title: tab.title ?? "",
-            url: tab.url ?? "",
-            active: Boolean(tab.active)
-          }
+          tab: toTabInfo(tab)
         };
       }
       case "tabs.focus": {
@@ -335,164 +1089,275 @@
         return { ok: true };
       }
       case "tabs.new": {
-        const tab = await chrome.tabs.create({ url: params.url ?? "about:blank" });
-        return { tabId: tab.id };
+        if (typeof params.workspaceId === "string" || params.windowId === void 0) {
+          const opened = await preserveHumanFocus(true, async () => {
+            return await workspaceManager.openTab({
+              workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : DEFAULT_WORKSPACE_ID,
+              url: params.url ?? "about:blank",
+              active: params.active === true,
+              focus: false
+            });
+          });
+          return {
+            tabId: opened.tab.id,
+            windowId: opened.tab.windowId,
+            groupId: opened.workspace.groupId,
+            workspaceId: opened.workspace.id
+          };
+        }
+        const tab = await chrome.tabs.create({
+          url: params.url ?? "about:blank",
+          windowId: typeof params.windowId === "number" ? params.windowId : void 0,
+          active: params.active === true
+        });
+        if (params.addToGroup === true && typeof tab.id === "number") {
+          const groupId = await chrome.tabs.group({ tabIds: [tab.id] });
+          return {
+            tabId: tab.id,
+            windowId: tab.windowId,
+            groupId
+          };
+        }
+        return {
+          tabId: tab.id,
+          windowId: tab.windowId
+        };
       }
       case "tabs.close": {
         const tabId = Number(params.tabId);
         await chrome.tabs.remove(tabId);
         return { ok: true };
       }
+      case "workspace.ensure": {
+        return preserveHumanFocus(params.focus !== true, async () => {
+          return await workspaceManager.ensureWorkspace({
+            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+            focus: params.focus === true,
+            initialUrl: typeof params.url === "string" ? params.url : void 0
+          });
+        });
+      }
+      case "workspace.info": {
+        return {
+          workspace: await workspaceManager.getWorkspaceInfo(typeof params.workspaceId === "string" ? params.workspaceId : void 0)
+        };
+      }
+      case "workspace.openTab": {
+        return await preserveHumanFocus(params.focus !== true, async () => {
+          return await workspaceManager.openTab({
+            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+            url: typeof params.url === "string" ? params.url : void 0,
+            active: params.active === true,
+            focus: params.focus === true
+          });
+        });
+      }
+      case "workspace.listTabs": {
+        return await workspaceManager.listTabs(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+      }
+      case "workspace.getActiveTab": {
+        return await workspaceManager.getActiveTab(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+      }
+      case "workspace.setActiveTab": {
+        return await workspaceManager.setActiveTab(Number(params.tabId), typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+      }
+      case "workspace.focus": {
+        return await workspaceManager.focus(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+      }
+      case "workspace.reset": {
+        return await preserveHumanFocus(params.focus !== true, async () => {
+          return await workspaceManager.reset({
+            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+            focus: params.focus === true,
+            initialUrl: typeof params.url === "string" ? params.url : void 0
+          });
+        });
+      }
+      case "workspace.close": {
+        return await workspaceManager.close(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+      }
       case "page.goto": {
-        const tab = await withTab(params.tabId, {
-          requireSupportedAutomationUrl: false
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target, {
+            requireSupportedAutomationUrl: false
+          });
+          const url = String(params.url ?? "about:blank");
+          await chrome.tabs.update(tab.id, { url });
+          await waitForTabUrl(tab.id, url);
+          await forwardContentRpc(tab.id, "page.url", { tabId: tab.id }).catch(() => void 0);
+          await waitForTabComplete(tab.id, 5e3).catch(() => void 0);
+          return { ok: true };
         });
-        await chrome.tabs.update(tab.id, { url: String(params.url ?? "about:blank") });
-        await waitForTabComplete(tab.id);
-        return { ok: true };
       }
       case "page.back": {
-        const tab = await withTab(params.tabId);
-        await chrome.tabs.goBack(tab.id);
-        await waitForTabComplete(tab.id);
-        return { ok: true };
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await chrome.tabs.goBack(tab.id);
+          await waitForTabComplete(tab.id);
+          return { ok: true };
+        });
       }
       case "page.forward": {
-        const tab = await withTab(params.tabId);
-        await chrome.tabs.goForward(tab.id);
-        await waitForTabComplete(tab.id);
-        return { ok: true };
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await chrome.tabs.goForward(tab.id);
+          await waitForTabComplete(tab.id);
+          return { ok: true };
+        });
       }
       case "page.reload": {
-        const tab = await withTab(params.tabId);
-        await chrome.tabs.reload(tab.id);
-        await waitForTabComplete(tab.id);
-        return { ok: true };
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await chrome.tabs.reload(tab.id);
+          await waitForTabComplete(tab.id);
+          return { ok: true };
+        });
       }
       case "page.viewport": {
-        const tab = await withTab(params.tabId, {
-          requireSupportedAutomationUrl: false
-        });
-        if (typeof tab.windowId !== "number") {
-          throw toError("E_NOT_FOUND", "Tab window unavailable");
-        }
-        const width = typeof params.width === "number" ? Math.max(320, Math.floor(params.width)) : void 0;
-        const height = typeof params.height === "number" ? Math.max(320, Math.floor(params.height)) : void 0;
-        if (width || height) {
-          await chrome.windows.update(tab.windowId, {
-            width,
-            height
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target, {
+            requireSupportedAutomationUrl: false
           });
-        }
-        const viewport = await forwardContentRpc(tab.id, "page.viewport", {});
-        const viewWidth = typeof width === "number" ? width : viewport.width ?? tab.width ?? 0;
-        const viewHeight = typeof height === "number" ? height : viewport.height ?? tab.height ?? 0;
-        return {
-          width: viewWidth,
-          height: viewHeight,
-          devicePixelRatio: viewport.devicePixelRatio
-        };
+          if (typeof tab.windowId !== "number") {
+            throw toError("E_NOT_FOUND", "Tab window unavailable");
+          }
+          const width = typeof params.width === "number" ? Math.max(320, Math.floor(params.width)) : void 0;
+          const height = typeof params.height === "number" ? Math.max(320, Math.floor(params.height)) : void 0;
+          if (width || height) {
+            await chrome.windows.update(tab.windowId, {
+              width,
+              height
+            });
+          }
+          const viewport = await forwardContentRpc(tab.id, "page.viewport", {});
+          const viewWidth = typeof width === "number" ? width : viewport.width ?? tab.width ?? 0;
+          const viewHeight = typeof height === "number" ? height : viewport.height ?? tab.height ?? 0;
+          return {
+            width: viewWidth,
+            height: viewHeight,
+            devicePixelRatio: viewport.devicePixelRatio
+          };
+        });
       }
       case "page.snapshot": {
-        const tab = await withTab(params.tabId);
-        if (typeof tab.id !== "number" || typeof tab.windowId !== "number") {
-          throw toError("E_NOT_FOUND", "Tab missing id");
-        }
-        const includeBase64 = params.includeBase64 !== false;
-        const config = await getConfig();
-        const elements = await sendToContent(tab.id, {
-          type: "bak.collectElements",
-          debugRichText: config.debugRichText
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          if (typeof tab.id !== "number" || typeof tab.windowId !== "number") {
+            throw toError("E_NOT_FOUND", "Tab missing id");
+          }
+          const includeBase64 = params.includeBase64 !== false;
+          const config = await getConfig();
+          const elements = await sendToContent(tab.id, {
+            type: "bak.collectElements",
+            debugRichText: config.debugRichText
+          });
+          const imageData = await captureAlignedTabScreenshot(tab);
+          return {
+            imageBase64: includeBase64 ? imageData.replace(/^data:image\/png;base64,/, "") : "",
+            elements: elements.elements,
+            tabId: tab.id,
+            url: tab.url ?? ""
+          };
         });
-        const imageData = await captureAlignedTabScreenshot(tab);
-        return {
-          imageBase64: includeBase64 ? imageData.replace(/^data:image\/png;base64,/, "") : "",
-          elements: elements.elements,
-          tabId: tab.id,
-          url: tab.url ?? ""
-        };
       }
       case "element.click": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(tab.id, {
-          type: "bak.performAction",
-          action: "click",
-          locator: params.locator,
-          requiresConfirm: params.requiresConfirm === true
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(tab.id, {
+            type: "bak.performAction",
+            action: "click",
+            locator: params.locator,
+            requiresConfirm: params.requiresConfirm === true
+          });
+          if (!response.ok) {
+            throw response.error ?? toError("E_INTERNAL", "element.click failed");
+          }
+          return { ok: true };
         });
-        if (!response.ok) {
-          throw response.error ?? toError("E_INTERNAL", "element.click failed");
-        }
-        return { ok: true };
       }
       case "element.type": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(tab.id, {
-          type: "bak.performAction",
-          action: "type",
-          locator: params.locator,
-          text: String(params.text ?? ""),
-          clear: Boolean(params.clear),
-          requiresConfirm: params.requiresConfirm === true
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(tab.id, {
+            type: "bak.performAction",
+            action: "type",
+            locator: params.locator,
+            text: String(params.text ?? ""),
+            clear: Boolean(params.clear),
+            requiresConfirm: params.requiresConfirm === true
+          });
+          if (!response.ok) {
+            throw response.error ?? toError("E_INTERNAL", "element.type failed");
+          }
+          return { ok: true };
         });
-        if (!response.ok) {
-          throw response.error ?? toError("E_INTERNAL", "element.type failed");
-        }
-        return { ok: true };
       }
       case "element.scroll": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(tab.id, {
-          type: "bak.performAction",
-          action: "scroll",
-          locator: params.locator,
-          dx: Number(params.dx ?? 0),
-          dy: Number(params.dy ?? 320)
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(tab.id, {
+            type: "bak.performAction",
+            action: "scroll",
+            locator: params.locator,
+            dx: Number(params.dx ?? 0),
+            dy: Number(params.dy ?? 320)
+          });
+          if (!response.ok) {
+            throw response.error ?? toError("E_INTERNAL", "element.scroll failed");
+          }
+          return { ok: true };
         });
-        if (!response.ok) {
-          throw response.error ?? toError("E_INTERNAL", "element.scroll failed");
-        }
-        return { ok: true };
       }
       case "page.wait": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(tab.id, {
-          type: "bak.waitFor",
-          mode: String(params.mode ?? "selector"),
-          value: String(params.value ?? ""),
-          timeoutMs: Number(params.timeoutMs ?? 5e3)
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(tab.id, {
+            type: "bak.waitFor",
+            mode: String(params.mode ?? "selector"),
+            value: String(params.value ?? ""),
+            timeoutMs: Number(params.timeoutMs ?? 5e3)
+          });
+          if (!response.ok) {
+            throw response.error ?? toError("E_TIMEOUT", "page.wait failed");
+          }
+          return { ok: true };
         });
-        if (!response.ok) {
-          throw response.error ?? toError("E_TIMEOUT", "page.wait failed");
-        }
-        return { ok: true };
       }
       case "debug.getConsole": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(tab.id, {
-          type: "bak.getConsole",
-          limit: Number(params.limit ?? 50)
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(tab.id, {
+            type: "bak.getConsole",
+            limit: Number(params.limit ?? 50)
+          });
+          return { entries: response.entries };
         });
-        return { entries: response.entries };
       }
       case "ui.selectCandidate": {
-        const tab = await withTab(params.tabId);
-        const response = await sendToContent(
-          tab.id,
-          {
-            type: "bak.selectCandidate",
-            candidates: params.candidates
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const response = await sendToContent(
+            tab.id,
+            {
+              type: "bak.selectCandidate",
+              candidates: params.candidates
+            }
+          );
+          if (!response.ok || !response.selectedEid) {
+            throw response.error ?? toError("E_NEED_USER_CONFIRM", "User did not confirm candidate");
           }
-        );
-        if (!response.ok || !response.selectedEid) {
-          throw response.error ?? toError("E_NEED_USER_CONFIRM", "User did not confirm candidate");
-        }
-        return { selectedEid: response.selectedEid };
+          return { selectedEid: response.selectedEid };
+        });
       }
       default:
         if (rpcForwardMethods.has(request.method)) {
-          const tab = await withTab(params.tabId);
-          return forwardContentRpc(tab.id, request.method, params);
+          return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+            const tab = await withTab(target);
+            return await forwardContentRpc(tab.id, request.method, {
+              ...params,
+              tabId: tab.id
+            });
+          });
         }
         throw toError("E_NOT_FOUND", `Unsupported method from CLI bridge: ${request.method}`);
     }
@@ -572,6 +1437,46 @@
       ws?.close();
     });
   }
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    void loadWorkspaceState().then(async (state) => {
+      if (!state || !state.tabIds.includes(tabId)) {
+        return;
+      }
+      const nextTabIds = state.tabIds.filter((id) => id !== tabId);
+      await saveWorkspaceState({
+        ...state,
+        tabIds: nextTabIds,
+        activeTabId: state.activeTabId === tabId ? null : state.activeTabId,
+        primaryTabId: state.primaryTabId === tabId ? null : state.primaryTabId
+      });
+    });
+  });
+  chrome.tabs.onActivated.addListener((activeInfo) => {
+    void loadWorkspaceState().then(async (state) => {
+      if (!state || state.windowId !== activeInfo.windowId || !state.tabIds.includes(activeInfo.tabId)) {
+        return;
+      }
+      await saveWorkspaceState({
+        ...state,
+        activeTabId: activeInfo.tabId
+      });
+    });
+  });
+  chrome.windows.onRemoved.addListener((windowId) => {
+    void loadWorkspaceState().then(async (state) => {
+      if (!state || state.windowId !== windowId) {
+        return;
+      }
+      await saveWorkspaceState({
+        ...state,
+        windowId: null,
+        groupId: null,
+        tabIds: [],
+        activeTabId: null,
+        primaryTabId: null
+      });
+    });
+  });
   chrome.runtime.onInstalled.addListener(() => {
     void setConfig({ port: DEFAULT_PORT, debugRichText: false });
   });