@jackwener/opencli 1.5.5 → 1.5.7

package/extension/src/background.test.ts

@@ -35,8 +35,12 @@ function createChromeMock() {
     { id: 3, windowId: 1, url: 'chrome://extensions', title: 'chrome', active: false, status: 'complete' },
   ];
 
-  const query = vi.fn(async (queryInfo: { windowId?: number } = {}) => {
-    return tabs.filter((tab) => queryInfo.windowId === undefined || tab.windowId === queryInfo.windowId);
+  const query = vi.fn(async (queryInfo: { windowId?: number; active?: boolean } = {}) => {
+    return tabs.filter((tab) => {
+      if (queryInfo.windowId !== undefined && tab.windowId !== queryInfo.windowId) return false;
+      if (queryInfo.active !== undefined && !!tab.active !== queryInfo.active) return false;
+      return true;
+    });
   });
   const create = vi.fn(async ({ windowId, url, active }: { windowId?: number; url?: string; active?: boolean }) => {
     const tab: MockTab = {
@@ -84,6 +88,8 @@ function createChromeMock() {
     runtime: {
       onInstalled: { addListener: vi.fn() } as Listener<() => void>,
       onStartup: { addListener: vi.fn() } as Listener<() => void>,
+      onMessage: { addListener: vi.fn() } as Listener<(msg: unknown, sender: unknown, sendResponse: (value: unknown) => void) => void>,
+      getManifest: vi.fn(() => ({ version: 'test-version' })),
     },
     cookies: {
       getAll: vi.fn(async () => []),
@@ -193,4 +199,198 @@ describe('background tab isolation', () => {
       expect.objectContaining({ workspace: 'site:zhihu', windowId: 2 }),
     ]));
   });
+
+  it('rebinds site:notebooklm to the active notebook tab instead of a home tab', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-live';
+    tabs[1].title = 'Live Notebook';
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:notebooklm', 1);
+
+    const tabId = await mod.__test__.resolveTabId(undefined, 'site:notebooklm');
+
+    expect(tabId).toBe(2);
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('prefers a notebook tab over an active home tab for site:notebooklm', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-passive';
+    tabs[1].title = 'Notebook';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:notebooklm', 1);
+
+    const tabId = await mod.__test__.resolveTabId(undefined, 'site:notebooklm');
+
+    expect(tabId).toBe(2);
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('detaches an adopted workspace session on idle instead of closing the user window', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+    vi.useFakeTimers();
+
+    const mod = await import('./background');
+    mod.__test__.setSession('site:notebooklm', {
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    });
+
+    mod.__test__.resetWindowIdleTimer('site:notebooklm');
+    await vi.advanceTimersByTimeAsync(30001);
+
+    expect(chrome.windows.remove).not.toHaveBeenCalled();
+    expect(mod.__test__.getSession('site:notebooklm')).toBeNull();
+  });
+
+  it('binds the active NotebookLM tab into the workspace explicitly', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-active';
+    tabs[1].title = 'Bound Notebook';
+    tabs[1].active = true;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-current',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-current',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-active',
+        title: 'Bound Notebook',
+        workspace: 'site:notebooklm',
+      }),
+    });
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('bind-current falls back to another matching notebook tab in the current window', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].windowId = 2;
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-passive';
+    tabs[1].title = 'Passive Notebook';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-fallback',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-fallback',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-passive',
+        title: 'Passive Notebook',
+      }),
+    });
+  });
+
+  it('bind-current falls back to a matching notebook tab in another window of the same profile', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].windowId = 3;
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].windowId = 2;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-other-window';
+    tabs[1].title = 'Notebook In Other Window';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-cross-window',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-cross-window',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-other-window',
+        title: 'Notebook In Other Window',
+      }),
+    });
+  });
+
+  it('rejects bind-current when the active tab is not NotebookLM', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-miss',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-miss',
+      ok: false,
+      error: 'No visible tab matching notebooklm.google.com /notebook/',
+    });
+  });
 });

package/extension/src/background.ts

@@ -117,6 +117,8 @@ type AutomationSession = {
   windowId: number;
   idleTimer: ReturnType<typeof setTimeout> | null;
   idleDeadlineAt: number;
+  owned: boolean;
+  preferredTabId: number | null;
 };
 
 const automationSessions = new Map<string, AutomationSession>();
@@ -134,6 +136,11 @@ function resetWindowIdleTimer(workspace: string): void {
   session.idleTimer = setTimeout(async () => {
     const current = automationSessions.get(workspace);
     if (!current) return;
+    if (!current.owned) {
+      console.log(`[opencli] Borrowed workspace ${workspace} detached from window ${current.windowId} (idle timeout)`);
+      automationSessions.delete(workspace);
+      return;
+    }
     try {
       await chrome.windows.remove(current.windowId);
       console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
@@ -173,6 +180,8 @@ async function getAutomationWindow(workspace: string): Promise<number> {
     windowId: win.id!,
     idleTimer: null,
     idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+    owned: true,
+    preferredTabId: null,
   };
   automationSessions.set(workspace, session);
   console.log(`[opencli] Created automation window ${session.windowId} (${workspace})`);
@@ -252,6 +261,10 @@ async function handleCommand(cmd: Command): Promise<Result> {
         return await handleCloseWindow(cmd, workspace);
       case 'sessions':
         return await handleSessions(cmd);
+      case 'set-file-input':
+        return await handleSetFileInput(cmd, workspace);
+      case 'bind-current':
+        return await handleBindCurrent(cmd, workspace);
       default:
         return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
     }
@@ -299,6 +312,89 @@ function isTargetUrl(currentUrl: string | undefined, targetUrl: string): boolean
   return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(targetUrl);
 }
 
+function matchesDomain(url: string | undefined, domain: string): boolean {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === domain || parsed.hostname.endsWith(`.${domain}`);
+  } catch {
+    return false;
+  }
+}
+
+function matchesBindCriteria(tab: chrome.tabs.Tab, cmd: Command): boolean {
+  if (!tab.id || !isDebuggableUrl(tab.url)) return false;
+  if (cmd.matchDomain && !matchesDomain(tab.url, cmd.matchDomain)) return false;
+  if (cmd.matchPathPrefix) {
+    try {
+      const parsed = new URL(tab.url!);
+      if (!parsed.pathname.startsWith(cmd.matchPathPrefix)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isNotebooklmWorkspace(workspace: string): boolean {
+  return workspace === 'site:notebooklm';
+}
+
+function classifyNotebooklmUrl(url?: string): 'notebook' | 'home' | 'other' {
+  if (!url) return 'other';
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname !== 'notebooklm.google.com') return 'other';
+    return parsed.pathname.startsWith('/notebook/') ? 'notebook' : 'home';
+  } catch {
+    return 'other';
+  }
+}
+
+function scoreWorkspaceTab(workspace: string, tab: chrome.tabs.Tab): number {
+  if (!tab.id || !isDebuggableUrl(tab.url)) return -1;
+  if (isNotebooklmWorkspace(workspace)) {
+    const kind = classifyNotebooklmUrl(tab.url);
+    if (kind === 'other') return -1;
+    if (kind === 'notebook') return tab.active ? 400 : 300;
+    return tab.active ? 200 : 100;
+  }
+  return -1;
+}
+
+function setWorkspaceSession(workspace: string, session: Omit<AutomationSession, 'idleTimer' | 'idleDeadlineAt'>): void {
+  const existing = automationSessions.get(workspace);
+  if (existing?.idleTimer) clearTimeout(existing.idleTimer);
+  automationSessions.set(workspace, {
+    ...session,
+    idleTimer: null,
+    idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+  });
+}
+
+async function maybeBindWorkspaceToExistingTab(workspace: string): Promise<number | null> {
+  if (!isNotebooklmWorkspace(workspace)) return null;
+  const tabs = await chrome.tabs.query({});
+  let bestTab: chrome.tabs.Tab | null = null;
+  let bestScore = -1;
+  for (const tab of tabs) {
+    const score = scoreWorkspaceTab(workspace, tab);
+    if (score > bestScore) {
+      bestScore = score;
+      bestTab = tab;
+    }
+  }
+  if (!bestTab?.id || bestScore < 0) return null;
+  setWorkspaceSession(workspace, {
+    windowId: bestTab.windowId,
+    owned: false,
+    preferredTabId: bestTab.id,
+  });
+  console.log(`[opencli] Workspace ${workspace} bound to existing tab ${bestTab.id} in window ${bestTab.windowId}`);
+  resetWindowIdleTimer(workspace);
+  return bestTab.id;
+}
+
 /**
  * Resolve target tab in the automation window.
  * If explicit tabId is given, use that directly.
@@ -312,9 +408,12 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
     try {
       const tab = await chrome.tabs.get(tabId);
       const session = automationSessions.get(workspace);
-      if (isDebuggableUrl(tab.url) && session && tab.windowId === session.windowId) return tabId;
-      if (session && tab.windowId !== session.windowId) {
-        console.warn(`[opencli] Tab ${tabId} belongs to window ${tab.windowId}, not automation window ${session.windowId}, re-resolving`);
+      const matchesSession = session
+        ? (session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId)
+        : false;
+      if (isDebuggableUrl(tab.url) && matchesSession) return tabId;
+      if (session && !matchesSession) {
+        console.warn(`[opencli] Tab ${tabId} is not bound to workspace ${workspace}, re-resolving`);
       } else if (!isDebuggableUrl(tab.url)) {
         // Tab exists but URL is not debuggable — fall through to auto-resolve
         console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
@@ -325,6 +424,19 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
     }
   }
 
+  const adoptedTabId = await maybeBindWorkspaceToExistingTab(workspace);
+  if (adoptedTabId !== null) return adoptedTabId;
+
+  const existingSession = automationSessions.get(workspace);
+  if (existingSession?.preferredTabId !== null) {
+    try {
+      const preferredTab = await chrome.tabs.get(existingSession.preferredTabId);
+      if (isDebuggableUrl(preferredTab.url)) return preferredTab.id!;
+    } catch {
+      automationSessions.delete(workspace);
+    }
+  }
+
   // Get (or create) the automation window
   const windowId = await getAutomationWindow(workspace);
 
@@ -357,6 +469,14 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
 async function listAutomationTabs(workspace: string): Promise<chrome.tabs.Tab[]> {
   const session = automationSessions.get(workspace);
   if (!session) return [];
+  if (session.preferredTabId !== null) {
+    try {
+      return [await chrome.tabs.get(session.preferredTabId)];
+    } catch {
+      automationSessions.delete(workspace);
+      return [];
+    }
+  }
   try {
     return await chrome.tabs.query({ windowId: session.windowId });
   } catch {
@@ -568,10 +688,12 @@ async function handleScreenshot(cmd: Command, workspace: string): Promise<Result
 async function handleCloseWindow(cmd: Command, workspace: string): Promise<Result> {
   const session = automationSessions.get(workspace);
   if (session) {
-    try {
-      await chrome.windows.remove(session.windowId);
-    } catch {
-      // Window may already be closed
+    if (session.owned) {
+      try {
+        await chrome.windows.remove(session.windowId);
+      } catch {
+        // Window may already be closed
+      }
     }
     if (session.idleTimer) clearTimeout(session.idleTimer);
     automationSessions.delete(workspace);
@@ -579,6 +701,19 @@ async function handleCloseWindow(cmd: Command, workspace: string): Promise<Resul
   return { id: cmd.id, ok: true, data: { closed: true } };
 }
 
+async function handleSetFileInput(cmd: Command, workspace: string): Promise<Result> {
+  if (!cmd.files || !Array.isArray(cmd.files) || cmd.files.length === 0) {
+    return { id: cmd.id, ok: false, error: 'Missing or empty files array' };
+  }
+  const tabId = await resolveTabId(cmd.tabId, workspace);
+  try {
+    await executor.setFileInputFiles(tabId, cmd.files, cmd.selector);
+    return { id: cmd.id, ok: true, data: { count: cmd.files.length } };
+  } catch (err) {
+    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 async function handleSessions(cmd: Command): Promise<Result> {
   const now = Date.now();
   const data = await Promise.all([...automationSessions.entries()].map(async ([workspace, session]) => ({
@@ -590,11 +725,52 @@ async function handleSessions(cmd: Command): Promise<Result> {
   return { id: cmd.id, ok: true, data };
 }
 
+async function handleBindCurrent(cmd: Command, workspace: string): Promise<Result> {
+  const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+  const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+  const allTabs = await chrome.tabs.query({});
+  const boundTab = activeTabs.find((tab) => matchesBindCriteria(tab, cmd))
+    ?? fallbackTabs.find((tab) => matchesBindCriteria(tab, cmd))
+    ?? allTabs.find((tab) => matchesBindCriteria(tab, cmd));
+  if (!boundTab?.id) {
+    return {
+      id: cmd.id,
+      ok: false,
+      error: cmd.matchDomain || cmd.matchPathPrefix
+        ? `No visible tab matching ${cmd.matchDomain ?? 'domain'}${cmd.matchPathPrefix ? ` ${cmd.matchPathPrefix}` : ''}`
+        : 'No active debuggable tab found',
+    };
+  }
+
+  setWorkspaceSession(workspace, {
+    windowId: boundTab.windowId,
+    owned: false,
+    preferredTabId: boundTab.id,
+  });
+  resetWindowIdleTimer(workspace);
+  console.log(`[opencli] Workspace ${workspace} explicitly bound to tab ${boundTab.id} (${boundTab.url})`);
+  return {
+    id: cmd.id,
+    ok: true,
+    data: {
+      tabId: boundTab.id,
+      windowId: boundTab.windowId,
+      url: boundTab.url,
+      title: boundTab.title,
+      workspace,
+    },
+  };
+}
+
 export const __test__ = {
   handleNavigate,
   isTargetUrl,
   handleTabs,
   handleSessions,
+  handleBindCurrent,
+  resolveTabId,
+  resetWindowIdleTimer,
+  getSession: (workspace: string = 'default') => automationSessions.get(workspace) ?? null,
   getAutomationWindowId: (workspace: string = 'default') => automationSessions.get(workspace)?.windowId ?? null,
   setAutomationWindowId: (workspace: string, windowId: number | null) => {
     if (windowId === null) {
@@ -603,10 +779,13 @@ export const __test__ = {
       automationSessions.delete(workspace);
       return;
     }
-    automationSessions.set(workspace, {
+    setWorkspaceSession(workspace, {
       windowId,
-      idleTimer: null,
-      idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+      owned: true,
+      preferredTabId: null,
     });
   },
+  setSession: (workspace: string, session: { windowId: number; owned: boolean; preferredTabId: number | null }) => {
+    setWorkspaceSession(workspace, session);
+  },
 };

package/extension/src/cdp.ts

@@ -71,6 +71,18 @@ async function ensureAttached(tabId: number): Promise<void> {
   } catch {
     // Some pages may not need explicit enable
   }
+
+  // Disable breakpoints so that `debugger;` statements in page code don't
+  // pause execution.  Anti-bot scripts use `debugger;` traps to detect CDP —
+  // they measure the time gap caused by the pause. Deactivating breakpoints
+  // makes the engine skip `debugger;` entirely, neutralising the timing
+  // side-channel without patching page JS.
+  try {
+    await chrome.debugger.sendCommand({ tabId }, 'Debugger.enable');
+    await chrome.debugger.sendCommand({ tabId }, 'Debugger.setBreakpointsActive', { active: false });
+  } catch {
+    // Non-fatal: best-effort hardening
+  }
 }
 
 export async function evaluate(tabId: number, expression: string): Promise<unknown> {
@@ -147,6 +159,48 @@ export async function screenshot(
   }
 }
 
+/**
+ * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
+ * This bypasses the need to send large base64 payloads through the message channel —
+ * Chrome reads the files directly from the local filesystem.
+ *
+ * @param tabId - Target tab ID
+ * @param files - Array of absolute local file paths
+ * @param selector - CSS selector to find the file input (optional, defaults to first file input)
+ */
+export async function setFileInputFiles(
+  tabId: number,
+  files: string[],
+  selector?: string,
+): Promise<void> {
+  await ensureAttached(tabId);
+
+  // Enable DOM domain (required for DOM.querySelector and DOM.setFileInputFiles)
+  await chrome.debugger.sendCommand({ tabId }, 'DOM.enable');
+
+  // Get the document root
+  const doc = await chrome.debugger.sendCommand({ tabId }, 'DOM.getDocument') as {
+    root: { nodeId: number };
+  };
+
+  // Find the file input element
+  const query = selector || 'input[type="file"]';
+  const result = await chrome.debugger.sendCommand({ tabId }, 'DOM.querySelector', {
+    nodeId: doc.root.nodeId,
+    selector: query,
+  }) as { nodeId: number };
+
+  if (!result.nodeId) {
+    throw new Error(`No element found matching selector: ${query}`);
+  }
+
+  // Set files directly via CDP — Chrome reads from local filesystem
+  await chrome.debugger.sendCommand({ tabId }, 'DOM.setFileInputFiles', {
+    files,
+    nodeId: result.nodeId,
+  });
+}
+
 export async function detach(tabId: number): Promise<void> {
   if (!attached.has(tabId)) return;
   attached.delete(tabId);

package/extension/src/protocol.ts

@@ -5,7 +5,7 @@
  * Everything else is just JS code sent via 'exec'.
  */
 
-export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions';
+export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
 
 export interface Command {
   /** Unique request ID */
@@ -26,12 +26,20 @@ export interface Command {
   index?: number;
   /** Cookie domain filter */
   domain?: string;
+  /** Optional hostname/domain to require for current-tab binding */
+  matchDomain?: string;
+  /** Optional pathname prefix to require for current-tab binding */
+  matchPathPrefix?: string;
   /** Screenshot format: png (default) or jpeg */
   format?: 'png' | 'jpeg';
   /** JPEG quality (0-100), only for jpeg format */
   quality?: number;
   /** Whether to capture full page (not just viewport) */
   fullPage?: boolean;
+  /** Local file paths for set-file-input action */
+  files?: string[];
+  /** CSS selector for file input element (set-file-input action) */
+  selector?: string;
 }
 
 export interface Result {
@@ -54,7 +62,5 @@ export const DAEMON_PING_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}/ping`;
 
 /** Base reconnect delay for extension WebSocket (ms) */
 export const WS_RECONNECT_BASE_DELAY = 2000;
-/** Max reconnect delay (ms) */
-export const WS_RECONNECT_MAX_DELAY = 60000;
-/** Idle timeout before daemon auto-exits (ms) */
-export const DAEMON_IDLE_TIMEOUT = 5 * 60 * 1000;
+/** Max reconnect delay (ms) — kept short since daemon is long-lived */
+export const WS_RECONNECT_MAX_DELAY = 5000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.5.5",
+  "version": "1.5.7",
   "publishConfig": {
     "access": "public"
   },

package/scripts/postinstall.js

@@ -196,6 +196,22 @@ function main() {
     }
   }
 
+  // ── Spotify credentials template ────────────────────────────────────
+  const opencliDir = join(home, '.opencli');
+  const spotifyEnvFile = join(opencliDir, 'spotify.env');
+  ensureDir(opencliDir);
+  if (!existsSync(spotifyEnvFile)) {
+    writeFileSync(spotifyEnvFile,
+      `# Spotify credentials — get them at https://developer.spotify.com/dashboard\n` +
+      `# Add http://127.0.0.1:8888/callback as a Redirect URI in your Spotify app\n` +
+      `SPOTIFY_CLIENT_ID=your_spotify_client_id_here\n` +
+      `SPOTIFY_CLIENT_SECRET=your_spotify_client_secret_here\n`,
+      'utf8'
+    );
+    console.log(`✓ Spotify credentials template created at ${spotifyEnvFile}`);
+    console.log(`  Edit the file and add your Client ID and Secret, then run: opencli spotify auth`);
+  }
+
   // ── Browser Bridge setup hint ───────────────────────────────────────
   console.log('');
   console.log('  \x1b[1mNext step — Browser Bridge setup\x1b[0m');