@flrande/bak-extension 0.3.4 → 0.3.6

package/dist/.bak-e2e-build-stamp

@@ -1 +1 @@
-2026-03-09T06:27:35.243Z
+2026-03-09T12:16:27.259Z

package/dist/background.global.js

@@ -96,6 +96,16 @@
         repairActions.push("pruned-missing-tabs");
       }
       state.tabIds = tabs.map((tab) => tab.id);
+      if (state.windowId !== null) {
+        const ownership = await this.inspectWorkspaceWindowOwnership(state, state.windowId);
+        if (ownership.foreignTabs.length > 0) {
+          const migrated = await this.moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl);
+          window = migrated.window;
+          tabs = migrated.tabs;
+          state.tabIds = tabs.map((tab) => tab.id);
+          repairActions.push("migrated-dirty-window");
+        }
+      }
       if (tabs.length === 0) {
         const primary = await this.createWorkspaceTab({
           windowId: state.windowId,
@@ -189,7 +199,7 @@
       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")
+        ensured.created || ensured.repairActions.includes("recreated-window") || ensured.repairActions.includes("created-primary-tab") || ensured.repairActions.includes("migrated-dirty-window")
       );
       let createdTab;
       try {
@@ -527,6 +537,79 @@
       }
       return null;
     }
+    async inspectWorkspaceWindowOwnership(state, windowId) {
+      const windowTabs = await this.waitForWindowTabs(windowId, 500);
+      const trackedIds = new Set(this.collectCandidateTabIds(state));
+      return {
+        workspaceTabs: windowTabs.filter((tab) => trackedIds.has(tab.id) || state.groupId !== null && tab.groupId === state.groupId),
+        foreignTabs: windowTabs.filter((tab) => !trackedIds.has(tab.id) && (state.groupId === null || tab.groupId !== state.groupId))
+      };
+    }
+    async moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl) {
+      const sourceTabs = this.orderWorkspaceTabsForMigration(state, ownership.workspaceTabs);
+      const seedUrl = sourceTabs[0]?.url ?? initialUrl;
+      const window = await this.browser.createWindow({
+        url: seedUrl || DEFAULT_WORKSPACE_URL,
+        focused: false
+      });
+      const recreatedTabs = await this.waitForWindowTabs(window.id);
+      const firstTab = recreatedTabs[0] ?? null;
+      const tabIdMap = /* @__PURE__ */ new Map();
+      if (sourceTabs[0] && firstTab) {
+        tabIdMap.set(sourceTabs[0].id, firstTab.id);
+      }
+      for (const sourceTab of sourceTabs.slice(1)) {
+        const recreated = await this.createWorkspaceTab({
+          windowId: window.id,
+          url: sourceTab.url,
+          active: false
+        });
+        recreatedTabs.push(recreated);
+        tabIdMap.set(sourceTab.id, recreated.id);
+      }
+      const nextPrimaryTabId = (state.primaryTabId !== null ? tabIdMap.get(state.primaryTabId) : void 0) ?? firstTab?.id ?? recreatedTabs[0]?.id ?? null;
+      const nextActiveTabId = (state.activeTabId !== null ? tabIdMap.get(state.activeTabId) : void 0) ?? nextPrimaryTabId ?? recreatedTabs[0]?.id ?? null;
+      if (nextActiveTabId !== null) {
+        await this.browser.updateTab(nextActiveTabId, { active: true });
+      }
+      state.windowId = window.id;
+      state.groupId = null;
+      state.tabIds = recreatedTabs.map((tab) => tab.id);
+      state.primaryTabId = nextPrimaryTabId;
+      state.activeTabId = nextActiveTabId;
+      for (const workspaceTab of ownership.workspaceTabs) {
+        await this.browser.closeTab(workspaceTab.id);
+      }
+      return {
+        window,
+        tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
+      };
+    }
+    orderWorkspaceTabsForMigration(state, tabs) {
+      const ordered = [];
+      const seen = /* @__PURE__ */ new Set();
+      const pushById = (tabId) => {
+        if (typeof tabId !== "number") {
+          return;
+        }
+        const tab = tabs.find((candidate) => candidate.id === tabId);
+        if (!tab || seen.has(tab.id)) {
+          return;
+        }
+        ordered.push(tab);
+        seen.add(tab.id);
+      };
+      pushById(state.primaryTabId);
+      pushById(state.activeTabId);
+      for (const tab of tabs) {
+        if (seen.has(tab.id)) {
+          continue;
+        }
+        ordered.push(tab);
+        seen.add(tab.id);
+      }
+      return ordered;
+    }
     async recoverWorkspaceTabs(state, existingTabs) {
       if (state.windowId === null) {
         return existingTabs;
@@ -980,6 +1063,32 @@
     }
     throw new Error(`tab url timeout: ${tabId} -> ${expectedUrl}`);
   }
+  async function finalizeOpenedWorkspaceTab(opened, expectedUrl) {
+    if (expectedUrl && expectedUrl !== "about:blank") {
+      await waitForTabUrl(opened.tab.id, expectedUrl).catch(() => void 0);
+    }
+    let refreshedTab = opened.tab;
+    try {
+      const rawTab = await chrome.tabs.get(opened.tab.id);
+      const pendingUrl = "pendingUrl" in rawTab && typeof rawTab.pendingUrl === "string" ? rawTab.pendingUrl : "";
+      const currentUrl = rawTab.url ?? "";
+      const effectiveUrl = currentUrl && currentUrl !== "about:blank" ? currentUrl : pendingUrl && pendingUrl !== "about:blank" ? pendingUrl : currentUrl || pendingUrl || opened.tab.url;
+      refreshedTab = {
+        ...toTabInfo(rawTab),
+        url: effectiveUrl
+      };
+    } catch {
+      refreshedTab = await workspaceBrowser.getTab(opened.tab.id) ?? opened.tab;
+    }
+    const refreshedWorkspace = await workspaceManager.getWorkspaceInfo(opened.workspace.id) ?? {
+      ...opened.workspace,
+      tabs: opened.workspace.tabs.map((tab) => tab.id === refreshedTab.id ? refreshedTab : tab)
+    };
+    return {
+      workspace: refreshedWorkspace,
+      tab: refreshedTab
+    };
+  }
   async function withTab(target = {}, options = {}) {
     const requireSupportedAutomationUrl = options.requireSupportedAutomationUrl !== false;
     const validate = (tab2) => {
@@ -1179,19 +1288,21 @@
       }
       case "tabs.new": {
         if (typeof params.workspaceId === "string" || params.windowId === void 0) {
+          const expectedUrl = params.url ?? "about:blank";
           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",
+              url: expectedUrl,
               active: params.active === true,
               focus: false
             });
           });
+          const stabilized = await finalizeOpenedWorkspaceTab(opened, expectedUrl);
           return {
-            tabId: opened.tab.id,
-            windowId: opened.tab.windowId,
-            groupId: opened.workspace.groupId,
-            workspaceId: opened.workspace.id
+            tabId: stabilized.tab.id,
+            windowId: stabilized.tab.windowId,
+            groupId: stabilized.workspace.groupId,
+            workspaceId: stabilized.workspace.id
           };
         }
         const tab = await chrome.tabs.create({
@@ -1232,14 +1343,16 @@
         };
       }
       case "workspace.openTab": {
-        return await preserveHumanFocus(params.focus !== true, async () => {
+        const expectedUrl = typeof params.url === "string" ? params.url : void 0;
+        const opened = 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,
+            url: expectedUrl,
             active: params.active === true,
             focus: params.focus === true
           });
         });
+        return await finalizeOpenedWorkspaceTab(opened, expectedUrl);
       }
       case "workspace.listTabs": {
         return await workspaceManager.listTabs(typeof params.workspaceId === "string" ? params.workspaceId : void 0);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@flrande/bak-extension",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
   "dependencies": {
-    "@flrande/bak-protocol": "0.3.4"
+    "@flrande/bak-protocol": "0.3.6"
   },
   "devDependencies": {
     "@types/chrome": "^0.1.14",

package/src/background.ts

@@ -390,6 +390,42 @@ async function waitForTabUrl(tabId: number, expectedUrl: string, timeoutMs = 10_
   throw new Error(`tab url timeout: ${tabId} -> ${expectedUrl}`);
 }
 
+async function finalizeOpenedWorkspaceTab(
+  opened: Awaited<ReturnType<WorkspaceManager['openTab']>>,
+  expectedUrl?: string
+): Promise<Awaited<ReturnType<WorkspaceManager['openTab']>>> {
+  if (expectedUrl && expectedUrl !== 'about:blank') {
+    await waitForTabUrl(opened.tab.id, expectedUrl).catch(() => undefined);
+  }
+  let refreshedTab = opened.tab;
+  try {
+    const rawTab = await chrome.tabs.get(opened.tab.id);
+    const pendingUrl = 'pendingUrl' in rawTab && typeof rawTab.pendingUrl === 'string' ? rawTab.pendingUrl : '';
+    const currentUrl = rawTab.url ?? '';
+    const effectiveUrl =
+      currentUrl && currentUrl !== 'about:blank'
+        ? currentUrl
+        : pendingUrl && pendingUrl !== 'about:blank'
+          ? pendingUrl
+          : currentUrl || pendingUrl || opened.tab.url;
+    refreshedTab = {
+      ...toTabInfo(rawTab),
+      url: effectiveUrl
+    };
+  } catch {
+    refreshedTab = (await workspaceBrowser.getTab(opened.tab.id)) ?? opened.tab;
+  }
+  const refreshedWorkspace = (await workspaceManager.getWorkspaceInfo(opened.workspace.id)) ?? {
+    ...opened.workspace,
+    tabs: opened.workspace.tabs.map((tab) => (tab.id === refreshedTab.id ? refreshedTab : tab))
+  };
+
+  return {
+    workspace: refreshedWorkspace,
+    tab: refreshedTab
+  };
+}
+
 interface WithTabOptions {
   requireSupportedAutomationUrl?: boolean;
 }
@@ -634,19 +670,21 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
     }
     case 'tabs.new': {
       if (typeof params.workspaceId === 'string' || params.windowId === undefined) {
+        const expectedUrl = (params.url as string | undefined) ?? 'about:blank';
         const opened = await preserveHumanFocus(true, async () => {
           return await workspaceManager.openTab({
             workspaceId: typeof params.workspaceId === 'string' ? params.workspaceId : DEFAULT_WORKSPACE_ID,
-            url: (params.url as string | undefined) ?? 'about:blank',
+            url: expectedUrl,
             active: params.active === true,
             focus: false
           });
         });
+        const stabilized = await finalizeOpenedWorkspaceTab(opened, expectedUrl);
         return {
-          tabId: opened.tab.id,
-          windowId: opened.tab.windowId,
-          groupId: opened.workspace.groupId,
-          workspaceId: opened.workspace.id
+          tabId: stabilized.tab.id,
+          windowId: stabilized.tab.windowId,
+          groupId: stabilized.workspace.groupId,
+          workspaceId: stabilized.workspace.id
         };
       }
       const tab = await chrome.tabs.create({
@@ -687,14 +725,16 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
       };
     }
     case 'workspace.openTab': {
-      return await preserveHumanFocus(params.focus !== true, async () => {
+      const expectedUrl = typeof params.url === 'string' ? params.url : undefined;
+      const opened = await preserveHumanFocus(params.focus !== true, async () => {
         return await workspaceManager.openTab({
           workspaceId: typeof params.workspaceId === 'string' ? params.workspaceId : undefined,
-          url: typeof params.url === 'string' ? params.url : undefined,
+          url: expectedUrl,
           active: params.active === true,
           focus: params.focus === true
         });
       });
+      return await finalizeOpenedWorkspaceTab(opened, expectedUrl);
     }
     case 'workspace.listTabs': {
       return await workspaceManager.listTabs(typeof params.workspaceId === 'string' ? params.workspaceId : undefined);

package/src/workspace.ts

@@ -79,6 +79,11 @@ export interface WorkspaceBrowser {
   updateGroup(groupId: number, options: { title?: string; color?: WorkspaceColor; collapsed?: boolean }): Promise<WorkspaceGroup>;
 }
 
+interface WorkspaceWindowOwnership {
+  workspaceTabs: WorkspaceTab[];
+  foreignTabs: WorkspaceTab[];
+}
+
 export interface WorkspaceEnsureOptions {
   workspaceId?: string;
   focus?: boolean;
@@ -165,6 +170,17 @@ export class WorkspaceManager {
     }
     state.tabIds = tabs.map((tab) => tab.id);
 
+    if (state.windowId !== null) {
+      const ownership = await this.inspectWorkspaceWindowOwnership(state, state.windowId);
+      if (ownership.foreignTabs.length > 0) {
+        const migrated = await this.moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl);
+        window = migrated.window;
+        tabs = migrated.tabs;
+        state.tabIds = tabs.map((tab) => tab.id);
+        repairActions.push('migrated-dirty-window');
+      }
+    }
+
     if (tabs.length === 0) {
       const primary = await this.createWorkspaceTab({
         windowId: state.windowId,
@@ -267,7 +283,10 @@ export class WorkspaceManager {
     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')
+      ensured.created ||
+        ensured.repairActions.includes('recreated-window') ||
+        ensured.repairActions.includes('created-primary-tab') ||
+        ensured.repairActions.includes('migrated-dirty-window')
     );
 
     let createdTab: WorkspaceTab;
@@ -647,6 +666,97 @@ export class WorkspaceManager {
     return null;
   }
 
+  private async inspectWorkspaceWindowOwnership(state: WorkspaceRecord, windowId: number): Promise<WorkspaceWindowOwnership> {
+    const windowTabs = await this.waitForWindowTabs(windowId, 500);
+    const trackedIds = new Set(this.collectCandidateTabIds(state));
+    return {
+      workspaceTabs: windowTabs.filter((tab) => trackedIds.has(tab.id) || (state.groupId !== null && tab.groupId === state.groupId)),
+      foreignTabs: windowTabs.filter((tab) => !trackedIds.has(tab.id) && (state.groupId === null || tab.groupId !== state.groupId))
+    };
+  }
+
+  private async moveWorkspaceIntoDedicatedWindow(
+    state: WorkspaceRecord,
+    ownership: WorkspaceWindowOwnership,
+    initialUrl: string
+  ): Promise<{ window: WorkspaceWindow; tabs: WorkspaceTab[] }> {
+    const sourceTabs = this.orderWorkspaceTabsForMigration(state, ownership.workspaceTabs);
+    const seedUrl = sourceTabs[0]?.url ?? initialUrl;
+    const window = await this.browser.createWindow({
+      url: seedUrl || DEFAULT_WORKSPACE_URL,
+      focused: false
+    });
+    const recreatedTabs = await this.waitForWindowTabs(window.id);
+    const firstTab = recreatedTabs[0] ?? null;
+    const tabIdMap = new Map<number, number>();
+    if (sourceTabs[0] && firstTab) {
+      tabIdMap.set(sourceTabs[0].id, firstTab.id);
+    }
+
+    for (const sourceTab of sourceTabs.slice(1)) {
+      const recreated = await this.createWorkspaceTab({
+        windowId: window.id,
+        url: sourceTab.url,
+        active: false
+      });
+      recreatedTabs.push(recreated);
+      tabIdMap.set(sourceTab.id, recreated.id);
+    }
+
+    const nextPrimaryTabId =
+      (state.primaryTabId !== null ? tabIdMap.get(state.primaryTabId) : undefined) ??
+      firstTab?.id ??
+      recreatedTabs[0]?.id ??
+      null;
+    const nextActiveTabId =
+      (state.activeTabId !== null ? tabIdMap.get(state.activeTabId) : undefined) ?? nextPrimaryTabId ?? recreatedTabs[0]?.id ?? null;
+    if (nextActiveTabId !== null) {
+      await this.browser.updateTab(nextActiveTabId, { active: true });
+    }
+
+    state.windowId = window.id;
+    state.groupId = null;
+    state.tabIds = recreatedTabs.map((tab) => tab.id);
+    state.primaryTabId = nextPrimaryTabId;
+    state.activeTabId = nextActiveTabId;
+
+    for (const workspaceTab of ownership.workspaceTabs) {
+      await this.browser.closeTab(workspaceTab.id);
+    }
+
+    return {
+      window,
+      tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
+    };
+  }
+
+  private orderWorkspaceTabsForMigration(state: WorkspaceRecord, tabs: WorkspaceTab[]): WorkspaceTab[] {
+    const ordered: WorkspaceTab[] = [];
+    const seen = new Set<number>();
+    const pushById = (tabId: number | null): void => {
+      if (typeof tabId !== 'number') {
+        return;
+      }
+      const tab = tabs.find((candidate) => candidate.id === tabId);
+      if (!tab || seen.has(tab.id)) {
+        return;
+      }
+      ordered.push(tab);
+      seen.add(tab.id);
+    };
+
+    pushById(state.primaryTabId);
+    pushById(state.activeTabId);
+    for (const tab of tabs) {
+      if (seen.has(tab.id)) {
+        continue;
+      }
+      ordered.push(tab);
+      seen.add(tab.id);
+    }
+    return ordered;
+  }
+
   private async recoverWorkspaceTabs(state: WorkspaceRecord, existingTabs: WorkspaceTab[]): Promise<WorkspaceTab[]> {
     if (state.windowId === null) {
       return existingTabs;