@aryanduntley/pwa-debug 0.1.7 → 0.1.8

package/dist/main.js

@@ -14871,6 +14871,90 @@ const registerChromeDevtoolsTool = Object.freeze({
     handler: registerChromeDevtoolsHandler,
 });
 
+// The SW waits up to timeout_ms (capped below) for the page to finish loading
+// before replying, so the IPC budget must comfortably exceed it.
+const NAV_MAX_LOAD_TIMEOUT_MS = 12_000;
+const NAV_IPC_TIMEOUT_MS = NAV_MAX_LOAD_TIMEOUT_MS + 3_000;
+const navigateInputSchema = {
+    extension_id: stringType().min(1).optional(),
+    tab_id: numberType().int().optional(),
+    url: stringType().min(1),
+    timeout_ms: numberType().int().positive().max(NAV_MAX_LOAD_TIMEOUT_MS).optional(),
+};
+const newTabInputSchema = {
+    extension_id: stringType().min(1).optional(),
+    url: stringType().min(1),
+    active: booleanType().optional(),
+    timeout_ms: numberType().int().positive().max(NAV_MAX_LOAD_TIMEOUT_MS).optional(),
+};
+/**
+ * Shared IPC round-trip for the navigation tools: resolve the target NMH, send a
+ * single request envelope to the SW, and normalize transport vs. handler errors.
+ * The SW handler (request_router) drives chrome.tabs and waits for load-complete.
+ */
+const sendNavRequest = async (ctx, extensionId, tool, payload, nextSteps) => {
+    const target = resolveTarget$1(ctx, extensionId);
+    if (!target.ok) {
+        return errorResponse(target.error, [
+            'Call host_status to see activeConnections. If empty, ensure host_register_extension has been called and the extension reloaded at chrome://extensions.',
+        ]);
+    }
+    const env = Object.freeze({
+        type: 'request',
+        requestId: randomUUID(),
+        tool,
+        extensionId: target.extensionId,
+        payload,
+    });
+    let response;
+    try {
+        response = await ctx.ipcServer.request(target.extensionId, env, {
+            timeoutMs: NAV_IPC_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        return errorResponse(`${tool} failed: ${err.message}`, [
+            `IPC request did not complete. Confirm the SW is connected and the ${tool} handler is wired in the SW.`,
+        ]);
+    }
+    if (response.error) {
+        return errorResponse(`${tool} nmh error: ${response.error.message}`, [
+            'The SW rejected the navigation (invalid URL, no active tab, or chrome.tabs threw). Pass an explicit tab_id, or open a tab first.',
+        ]);
+    }
+    const data = {
+        extensionId: target.extensionId,
+        ...response.payload,
+    };
+    return okResponse(data, [...nextSteps]);
+};
+const navigateHandler = async (args, ctx) => sendNavRequest(ctx, args.extension_id, 'pdl_navigate', {
+    url: args.url,
+    ...(args.tab_id !== undefined ? { tab_id: args.tab_id } : {}),
+    ...(args.timeout_ms !== undefined ? { timeout_ms: args.timeout_ms } : {}),
+}, [
+    'Navigated the active (or given) tab. Returns { tabId, url, status }: status "complete" = page finished loading; "loading" = navigation happened but the load was still in flight when the wait elapsed (raise timeout_ms, or poll session_ping). pwa-debug capture/inspection tools now target the new page.',
+]);
+const newTabHandler = async (args, ctx) => sendNavRequest(ctx, args.extension_id, 'pdl_new_tab', {
+    url: args.url,
+    ...(args.active !== undefined ? { active: args.active } : {}),
+    ...(args.timeout_ms !== undefined ? { timeout_ms: args.timeout_ms } : {}),
+}, [
+    'Opened a new tab. Returns { tabId, url, status, created:true }. Pass the returned tabId to other pwa-debug tools (react_tree, console_tail, pdl_click, …) to target this tab; without tab_id they use the active tab.',
+]);
+const navigateTool = Object.freeze({
+    name: 'pdl_navigate',
+    description: "Navigate a browser tab to a URL, driven through the pwa-debug extension's service worker (chrome.tabs.update) — NO CDP, so it works on the user's real, logged-in profile without chrome-devtools-mcp being registered or attached. Targets the active tab in the last-focused window unless tab_id is given. The URL may omit the scheme (https:// is assumed); a javascript: URL is rejected. Waits for the page to reach document 'complete' (up to timeout_ms, default 10000, max 12000) before returning { extensionId, tabId, url, status, windowId? }, where status is 'complete' or 'loading' (load still in flight at timeout — the navigation still happened). Args: { url: non-empty string, tab_id?, timeout_ms?, extension_id? }. With no extension_id/tab_id, targets the single connected NMH and the active tab. CALL host_status FIRST to confirm a connection.",
+    inputSchema: navigateInputSchema,
+    handler: navigateHandler,
+});
+const newTabTool = Object.freeze({
+    name: 'pdl_new_tab',
+    description: "Open a NEW browser tab at a URL via the pwa-debug extension's service worker (chrome.tabs.create) — NO CDP, works on the user's real profile with no chrome-devtools-mcp dependency. The URL may omit the scheme (https:// is assumed); a javascript: URL is rejected. active? controls foreground vs. background (defaults to foreground). Waits for the page to reach document 'complete' (up to timeout_ms, default 10000, max 12000) before returning { extensionId, tabId, url, status, windowId?, created:true }. Pass the returned tabId to other pwa-debug tools to target this tab specifically. Args: { url: non-empty string, active?, timeout_ms?, extension_id? }. With no extension_id, targets the single connected NMH. CALL host_status FIRST to confirm a connection.",
+    inputSchema: newTabInputSchema,
+    handler: newTabHandler,
+});
+
 const ACTION_IPC_TIMEOUT_MS = 5000;
 // Locator + routing fields shared by every action tool.
 const locatorSchema = {
@@ -15041,6 +15125,8 @@ const TOOLS = Object.freeze([
     storageGetTool,
     idbListTool,
     idbQueryTool,
+    navigateTool,
+    newTabTool,
     launchBrowserTool,
     browserStatusTool,
     closeBrowserTool,

package/extension/service-worker.js

@@ -176,6 +176,110 @@ const dispatchToTabClassified = async (tabId, req, opts = {}) => {
     return { ok: true, response };
 };
 
+// SW-side navigation primitives — wraps chrome.tabs URL navigation so the request
+// router stays a thin orchestrator. SW-handled (NOT page-world): chrome.tabs is
+// only reachable in the extension service worker, and driving the tab to a new URL
+// is a browser action, not an in-page read. This is the pwa-debug counterpart to
+// chrome-devtools-mcp's navigate_page/new_page — it works through the loaded
+// extension on the user's real profile, with no CDP attach required.
+const DEFAULT_LOAD_TIMEOUT_MS = 10_000;
+// A bare javascript: URL would run script in the target page context on navigate;
+// reject it. Everything else (http(s), file:, about:, data:, chrome:, localhost
+// shorthand) is allowed — this is a debugging driver, not a sandbox.
+const JAVASCRIPT_SCHEME = /^javascript:/i;
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+ * Normalize a caller-supplied URL: trim, reject empty / javascript:, and assume
+ * https:// when no scheme is given (so `example.com` works). Returns null when the
+ * input is unusable so the caller can surface a clear error.
+ */
+const normalizeUrl = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    if (JAVASCRIPT_SCHEME.test(trimmed))
+        return null;
+    return HAS_SCHEME.test(trimmed) ? trimmed : `https://${trimmed}`;
+};
+/** Active tab id in the last-focused window, or undefined when there is none. */
+const activeTabId = async () => {
+    const tabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+    return tabs[0]?.id;
+};
+/**
+ * Resolve once the tab reports document 'complete', or 'timeout' after timeoutMs.
+ * The onUpdated listener is added BEFORE the caller triggers the load so the
+ * 'complete' event can't be missed; it is always removed and the timer cleared.
+ */
+const waitForComplete = (tabId, timeoutMs) => new Promise((resolve) => {
+    let settled = false;
+    const settle = (outcome) => {
+        if (settled)
+            return;
+        settled = true;
+        chrome.tabs.onUpdated.removeListener(onUpdated);
+        clearTimeout(timer);
+        resolve(outcome);
+    };
+    const onUpdated = (id, info) => {
+        if (id === tabId && info.status === 'complete')
+            settle('complete');
+    };
+    const timer = setTimeout(() => settle('timeout'), timeoutMs);
+    chrome.tabs.onUpdated.addListener(onUpdated);
+});
+/**
+ * Navigate the active (or given) tab to url and wait for it to finish loading.
+ * Throws on an invalid url or when no tab can be resolved. The listener is armed
+ * before chrome.tabs.update so the fresh load's 'complete' is observed.
+ */
+const navigateTab = async (input) => {
+    const url = normalizeUrl(input.url);
+    if (url === null) {
+        throw new Error(`navigate: invalid or unsupported url: ${JSON.stringify(input.url)}`);
+    }
+    const tabId = input.tabId ?? (await activeTabId());
+    if (tabId === undefined) {
+        throw new Error('navigate: no active tab (open a tab or pass tab_id)');
+    }
+    const pending = waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
+    const tab = await chrome.tabs.update(tabId, { url });
+    const outcome = await pending;
+    return {
+        tabId,
+        url,
+        ...(tab?.windowId !== undefined ? { windowId: tab.windowId } : {}),
+        status: outcome === 'complete' ? 'complete' : 'loading',
+    };
+};
+/**
+ * Open a new tab at url and wait for it to finish loading. active defaults to
+ * Chrome's behavior (foreground). Throws on an invalid url or when Chrome returns
+ * no tab id.
+ */
+const openNewTab = async (input) => {
+    const url = normalizeUrl(input.url);
+    if (url === null) {
+        throw new Error(`new_tab: invalid or unsupported url: ${JSON.stringify(input.url)}`);
+    }
+    const tab = await chrome.tabs.create({
+        url,
+        ...(input.active !== undefined ? { active: input.active } : {}),
+    });
+    const tabId = tab.id;
+    if (tabId === undefined) {
+        throw new Error('new_tab: chrome did not return a tab id');
+    }
+    const outcome = await waitForComplete(tabId, input.timeoutMs ?? DEFAULT_LOAD_TIMEOUT_MS);
+    return {
+        tabId,
+        url,
+        ...(tab.windowId !== undefined ? { windowId: tab.windowId } : {}),
+        status: outcome === 'complete' ? 'complete' : 'loading',
+        created: true,
+    };
+};
+
 const compilePatternList = (sources, fieldPathPrefix) => {
     if (sources === undefined || sources.length === 0) {
         return { ok: true, value: [] };
@@ -1610,6 +1714,50 @@ const handleSessionRecord = async (env) => {
     }
     return response.payload;
 };
+// --- Navigation tools (pdl_navigate / pdl_new_tab) ---------------------------
+// SW-handled, NOT page-world: chrome.tabs drives the browser to a URL. Forwarded
+// to the sw_navigation module, which validates the URL and waits for load.
+const readTimeoutMs = (r) => typeof r['timeout_ms'] === 'number' &&
+    Number.isInteger(r['timeout_ms']) &&
+    r['timeout_ms'] > 0
+    ? r['timeout_ms']
+    : undefined;
+const handleNavigate = async (env) => {
+    const raw = env.payload;
+    if (raw === null || typeof raw !== 'object') {
+        throw new Error('pdl_navigate: payload must be { url: non-empty string, tab_id?, timeout_ms? }');
+    }
+    const r = raw;
+    const url = r['url'];
+    if (typeof url !== 'string' || url.length === 0) {
+        throw new Error('pdl_navigate: payload must include { url: non-empty string }');
+    }
+    const tabId = readTabId(raw);
+    const timeoutMs = readTimeoutMs(r);
+    return navigateTab({
+        url,
+        ...(tabId !== undefined ? { tabId } : {}),
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    });
+};
+const handleNewTab = async (env) => {
+    const raw = env.payload;
+    if (raw === null || typeof raw !== 'object') {
+        throw new Error('pdl_new_tab: payload must be { url: non-empty string, active?, timeout_ms? }');
+    }
+    const r = raw;
+    const url = r['url'];
+    if (typeof url !== 'string' || url.length === 0) {
+        throw new Error('pdl_new_tab: payload must include { url: non-empty string }');
+    }
+    const active = typeof r['active'] === 'boolean' ? r['active'] : undefined;
+    const timeoutMs = readTimeoutMs(r);
+    return openNewTab({
+        url,
+        ...(active !== undefined ? { active } : {}),
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    });
+};
 // --- Path 7 interaction action tools (pdl_*) ---------------------------------
 // One generic handler per ACTION_TOOL_SPECS entry: extract tab_id for routing,
 // forward the locator + params payload to the page-world unchanged.
@@ -1643,6 +1791,8 @@ const makeActionRequestHandler = (tool) => async (env) => {
 const actionRequestHandlers = Object.freeze(Object.fromEntries(ACTION_TOOL_SPECS.map((s) => [s.tool, makeActionRequestHandler(s.tool)])));
 const HANDLERS = Object.freeze({
     ...actionRequestHandlers,
+    pdl_navigate: handleNavigate,
+    pdl_new_tab: handleNewTab,
     session_ping: handleSessionPing,
     recent_events: handleRecentEvents,
     evaluate: handleEvaluate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aryanduntley/pwa-debug",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -63,8 +63,8 @@
     "@types/winreg": "^1.2.36",
     "rollup": "^4.27.4",
     "tslib": "^2.8.1",
-    "@pwa-debug/shared": "0.1.7",
-    "@pwa-debug/extension": "0.1.7"
+    "@pwa-debug/extension": "0.1.8",
+    "@pwa-debug/shared": "0.1.8"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",