opendevbrowser 0.0.15 → 0.0.16

package/dist/index.js

@@ -2,11 +2,22 @@ import {
   DaemonClient,
   ScriptRunner,
   buildAnnotateResult,
+  buildBlockerArtifacts,
+  classifyBlockerSignal,
+  createBrowserFallbackPort,
+  createConfiguredProviderRuntime,
   createOpenDevBrowserCore,
+  createRequestId,
+  executeMacroResolution,
   extractExtension,
   fetchDaemonStatusFromMetadata,
+  runProductVideoWorkflow,
+  runResearchWorkflow,
+  runShoppingWorkflow,
+  shapeExecutionPayload,
   startDaemon
-} from "./chunk-JVBMT2O5.js";
+} from "./chunk-ST7CO5FA.js";
+import "./chunk-7W3SPXIB.js";
 
 // src/cli/remote-manager.ts
 function isLegacyRelayEndpoint(wsEndpoint) {
@@ -41,77 +52,202 @@ var RemoteManager = class {
   status(sessionId) {
     return this.client.call("session.status", { sessionId });
   }
-  goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4) {
-    return this.client.call("nav.goto", { sessionId, url, waitUntil, timeoutMs });
+  cookieImport(sessionId, cookies, strict = true, requestId) {
+    return this.client.call("session.cookieImport", {
+      sessionId,
+      cookies,
+      strict,
+      requestId
+    });
   }
-  waitForLoad(sessionId, until, timeoutMs = 3e4) {
-    return this.client.call("nav.wait", { sessionId, until, timeoutMs });
+  cookieList(sessionId, urls, requestId) {
+    return this.client.call("session.cookieList", {
+      sessionId,
+      ...urls && urls.length > 0 ? { urls } : {},
+      requestId
+    });
   }
-  waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4) {
-    return this.client.call("nav.wait", { sessionId, ref, state, timeoutMs });
+  goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4, _sessionOverride, targetId) {
+    return this.client.call("nav.goto", {
+      sessionId,
+      url,
+      waitUntil,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  snapshot(sessionId, mode, maxChars, cursor) {
-    return this.client.call("nav.snapshot", { sessionId, mode, maxChars, cursor });
+  waitForLoad(sessionId, until, timeoutMs = 3e4, targetId) {
+    return this.client.call("nav.wait", {
+      sessionId,
+      until,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  click(sessionId, ref) {
-    return this.client.call("interact.click", { sessionId, ref });
+  waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4, targetId) {
+    return this.client.call("nav.wait", {
+      sessionId,
+      ref,
+      state,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  hover(sessionId, ref) {
-    return this.client.call("interact.hover", { sessionId, ref });
+  snapshot(sessionId, mode, maxChars, cursor, targetId) {
+    return this.client.call("nav.snapshot", {
+      sessionId,
+      mode,
+      maxChars,
+      cursor,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  press(sessionId, key, ref) {
-    return this.client.call("interact.press", { sessionId, key, ref });
+  click(sessionId, ref, targetId) {
+    return this.client.call("interact.click", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  check(sessionId, ref) {
-    return this.client.call("interact.check", { sessionId, ref });
+  hover(sessionId, ref, targetId) {
+    return this.client.call("interact.hover", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  uncheck(sessionId, ref) {
-    return this.client.call("interact.uncheck", { sessionId, ref });
+  press(sessionId, key, ref, targetId) {
+    return this.client.call("interact.press", {
+      sessionId,
+      key,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  type(sessionId, ref, text, clear = false, submit = false) {
-    return this.client.call("interact.type", { sessionId, ref, text, clear, submit });
+  check(sessionId, ref, targetId) {
+    return this.client.call("interact.check", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  select(sessionId, ref, values) {
-    return this.client.call("interact.select", { sessionId, ref, values });
+  uncheck(sessionId, ref, targetId) {
+    return this.client.call("interact.uncheck", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  scroll(sessionId, dy, ref) {
-    return this.client.call("interact.scroll", { sessionId, dy, ref });
+  type(sessionId, ref, text, clear = false, submit = false, targetId) {
+    return this.client.call("interact.type", {
+      sessionId,
+      ref,
+      text,
+      clear,
+      submit,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  scrollIntoView(sessionId, ref) {
-    return this.client.call("interact.scrollIntoView", { sessionId, ref });
+  select(sessionId, ref, values, targetId) {
+    return this.client.call("interact.select", {
+      sessionId,
+      ref,
+      values,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetHtml(sessionId, ref, maxChars = 8e3) {
-    return this.client.call("dom.getHtml", { sessionId, ref, maxChars });
+  scroll(sessionId, dy, ref, targetId) {
+    return this.client.call("interact.scroll", {
+      sessionId,
+      dy,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetText(sessionId, ref, maxChars = 8e3) {
-    return this.client.call("dom.getText", { sessionId, ref, maxChars });
+  scrollIntoView(sessionId, ref, targetId) {
+    return this.client.call("interact.scrollIntoView", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetAttr(sessionId, ref, name) {
-    return this.client.call("dom.getAttr", { sessionId, ref, name });
+  domGetHtml(sessionId, ref, maxChars = 8e3, targetId) {
+    return this.client.call("dom.getHtml", {
+      sessionId,
+      ref,
+      maxChars,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetValue(sessionId, ref) {
-    return this.client.call("dom.getValue", { sessionId, ref });
+  domGetText(sessionId, ref, maxChars = 8e3, targetId) {
+    return this.client.call("dom.getText", {
+      sessionId,
+      ref,
+      maxChars,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsVisible(sessionId, ref) {
-    return this.client.call("dom.isVisible", { sessionId, ref });
+  domGetAttr(sessionId, ref, name, targetId) {
+    return this.client.call("dom.getAttr", {
+      sessionId,
+      ref,
+      name,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsEnabled(sessionId, ref) {
-    return this.client.call("dom.isEnabled", { sessionId, ref });
+  domGetValue(sessionId, ref, targetId) {
+    return this.client.call("dom.getValue", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsChecked(sessionId, ref) {
-    return this.client.call("dom.isChecked", { sessionId, ref });
+  domIsVisible(sessionId, ref, targetId) {
+    return this.client.call("dom.isVisible", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  clonePage(sessionId) {
-    return this.client.call("export.clonePage", { sessionId });
+  domIsEnabled(sessionId, ref, targetId) {
+    return this.client.call("dom.isEnabled", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  cloneComponent(sessionId, ref) {
-    return this.client.call("export.cloneComponent", { sessionId, ref });
+  domIsChecked(sessionId, ref, targetId) {
+    return this.client.call("dom.isChecked", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  perfMetrics(sessionId) {
-    return this.client.call("devtools.perf", { sessionId });
+  clonePage(sessionId, targetId) {
+    return this.client.call("export.clonePage", {
+      sessionId,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  screenshot(sessionId, path) {
-    return this.client.call("page.screenshot", { sessionId, path });
+  cloneComponent(sessionId, ref, targetId) {
+    return this.client.call("export.cloneComponent", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  perfMetrics(sessionId, targetId) {
+    return this.client.call("devtools.perf", {
+      sessionId,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  screenshot(sessionId, path, targetId) {
+    return this.client.call("page.screenshot", {
+      sessionId,
+      path,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
   consolePoll(sessionId, sinceSeq, max = 50) {
     return this.client.call("devtools.consolePoll", { sessionId, sinceSeq, max });
@@ -209,7 +345,7 @@ var RemoteRelay = class {
 
 // src/skills/skill-nudge.ts
 var SKILL_NUDGE_MARKER = "[opendevbrowser:skill-nudge]";
-var SKILL_NUDGE_MESSAGE = `${SKILL_NUDGE_MARKER} If this task likely matches a skill, call the OpenCode skill tool early (skill("<skill-name>", topic?)) and load only the most relevant skill before using browser tools. If unsure which skill applies, check the available skills first.`;
+var SKILL_NUDGE_MESSAGE = `${SKILL_NUDGE_MARKER} If this task likely matches a skill, start with skill("opendevbrowser-best-practices", "quick start"). Use another skill only when it is more relevant.`;
 function createSkillNudgeState() {
   return { pending: false, requestedAtMs: null };
 }
@@ -272,7 +408,7 @@ function consumeContinuityNudge(state, nowMs, maxAgeMs) {
 }
 function buildContinuityNudgeMessage(filePath) {
   const target = filePath?.trim() || DEFAULT_FILE_PATH;
-  return `${CONTINUITY_NUDGE_MARKER} For long-running tasks, create or update ${target} at the repo root with Goal, Constraints/Assumptions, Key decisions, State (Done/Now/Next), Open questions, and Working set. Keep it brief.`;
+  return `${CONTINUITY_NUDGE_MARKER} For long-running tasks, load skill("opendevbrowser-continuity-ledger") and create or update ${target} at the repo root with Goal, Constraints/Assumptions, Key decisions, State (Done/Now/Next), Open questions, and Working set. Keep it brief.`;
 }
 
 // src/tools/launch.ts
@@ -333,6 +469,12 @@ function createLaunchTool(deps) {
           const headlessExplicit = args.headless === true;
           const managedExplicit = Boolean(args.noExtension || headlessExplicit);
           const managedHeadless = headlessExplicit ? true : false;
+          if (headlessExplicit && !args.noExtension) {
+            return failure(
+              "Extension mode does not support headless launches. Use noExtension=true with headless=true for managed mode.",
+              "unsupported_mode"
+            );
+          }
           if (args.waitForExtension && !managedExplicit) {
             const observedPort2 = resolveObservedPort(relayStatus, config.relayPort);
             const connected = await waitForExtensionHandshake(deps.relay, observedPort2, waitTimeoutMs);
@@ -1550,14 +1692,457 @@ function createNetworkPollTool(deps) {
   });
 }
 
-// src/tools/clone_page.ts
+// src/tools/debug_trace_snapshot.ts
 import { tool as tool35 } from "@opencode-ai/plugin";
 var z35 = tool35.schema;
-function createClonePageTool(deps) {
+function createDebugTraceSnapshotTool(deps) {
   return tool35({
+    description: "Capture a combined debug trace snapshot (page + console + network + exceptions).",
+    args: {
+      sessionId: z35.string().describe("Session id"),
+      sinceConsoleSeq: z35.number().int().optional().describe("Resume cursor for console events"),
+      sinceNetworkSeq: z35.number().int().optional().describe("Resume cursor for network events"),
+      sinceExceptionSeq: z35.number().int().optional().describe("Resume cursor for exception events"),
+      max: z35.number().int().optional().describe("Max events per channel"),
+      requestId: z35.string().optional().describe("Optional trace request id")
+    },
+    async execute(args) {
+      try {
+        const manager = deps.manager;
+        const options = {
+          sinceConsoleSeq: args.sinceConsoleSeq,
+          sinceNetworkSeq: args.sinceNetworkSeq,
+          sinceExceptionSeq: args.sinceExceptionSeq,
+          max: args.max,
+          requestId: args.requestId
+        };
+        if (typeof manager.debugTraceSnapshot === "function") {
+          const result = await manager.debugTraceSnapshot(args.sessionId, options);
+          return ok(result);
+        }
+        const max = args.max ?? 500;
+        const requestId = args.requestId ?? createRequestId();
+        const [page, consoleChannel, networkChannel] = await Promise.all([
+          deps.manager.status(args.sessionId),
+          deps.manager.consolePoll(args.sessionId, args.sinceConsoleSeq, max),
+          deps.manager.networkPoll(args.sessionId, args.sinceNetworkSeq, max)
+        ]);
+        const exceptionChannel = typeof manager.exceptionPoll === "function" ? await manager.exceptionPoll(args.sessionId, args.sinceExceptionSeq, max) : {
+          events: [],
+          nextSeq: args.sinceExceptionSeq ?? 0,
+          truncated: false
+        };
+        const annotateTraceContext = (events) => events.map((event) => ({
+          ...event,
+          requestId,
+          sessionId: args.sessionId
+        }));
+        const blocker = classifyBlockerSignal({
+          source: "network",
+          url: typeof page.url === "string" ? page.url : void 0,
+          finalUrl: typeof page.url === "string" ? page.url : void 0,
+          title: typeof page.title === "string" ? page.title : void 0,
+          status: findLatestStatus(networkChannel.events),
+          traceRequestId: requestId,
+          networkHosts: extractHosts(networkChannel.events),
+          threshold: deps.config.get().blockerDetectionThreshold,
+          promptGuardEnabled: deps.config.get().security.promptInjectionGuard?.enabled ?? true
+        });
+        const blockerArtifacts = blocker ? buildBlockerArtifacts({
+          networkEvents: networkChannel.events,
+          consoleEvents: consoleChannel.events,
+          exceptionEvents: exceptionChannel.events,
+          promptGuardEnabled: deps.config.get().security.promptInjectionGuard?.enabled ?? true,
+          caps: deps.config.get().blockerArtifactCaps
+        }) : void 0;
+        return ok({
+          requestId,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          page,
+          channels: {
+            console: {
+              nextSeq: consoleChannel.nextSeq,
+              truncated: consoleChannel.truncated,
+              events: annotateTraceContext(consoleChannel.events)
+            },
+            network: {
+              nextSeq: networkChannel.nextSeq,
+              truncated: networkChannel.truncated,
+              events: annotateTraceContext(networkChannel.events)
+            },
+            exception: {
+              nextSeq: exceptionChannel.nextSeq,
+              truncated: exceptionChannel.truncated,
+              events: annotateTraceContext(exceptionChannel.events)
+            }
+          },
+          meta: {
+            blockerState: blocker ? "active" : "clear",
+            ...blocker ? { blocker } : {},
+            ...blockerArtifacts ? { blockerArtifacts } : {}
+          }
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "debug_trace_snapshot_failed");
+      }
+    }
+  });
+}
+function findLatestStatus(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const status = events[index]?.status;
+    if (typeof status === "number") {
+      return status;
+    }
+  }
+  return void 0;
+}
+function extractHosts(events) {
+  const hosts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (typeof event.url !== "string") continue;
+    try {
+      const host = new URL(event.url).hostname.toLowerCase();
+      if (!host || seen.has(host)) continue;
+      seen.add(host);
+      hosts.push(host);
+    } catch {
+    }
+  }
+  return hosts;
+}
+
+// src/tools/cookie_import.ts
+import { tool as tool36 } from "@opencode-ai/plugin";
+var z36 = tool36.schema;
+function validateCookieRecord(cookie) {
+  const name = cookie.name?.trim();
+  if (!name) {
+    return { valid: false, reason: "Cookie name is required.", cookie };
+  }
+  if (!/^[^\s;=]+$/.test(name)) {
+    return { valid: false, reason: `Invalid cookie name: ${cookie.name}.`, cookie };
+  }
+  if (typeof cookie.value !== "string") {
+    return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+  }
+  const value = cookie.value;
+  if (/\r|\n|;/.test(value)) {
+    return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+  }
+  const hasUrl = typeof cookie.url === "string" && cookie.url.trim().length > 0;
+  const hasDomain = typeof cookie.domain === "string" && cookie.domain.trim().length > 0;
+  if (!hasUrl && !hasDomain) {
+    return { valid: false, reason: `Cookie ${name} requires url or domain.`, cookie };
+  }
+  let normalizedUrl;
+  if (hasUrl) {
+    try {
+      const parsedUrl = new URL(cookie.url);
+      if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        return { valid: false, reason: `Cookie ${name} url must be http(s).`, cookie };
+      }
+      normalizedUrl = parsedUrl.toString();
+    } catch {
+      return { valid: false, reason: `Cookie ${name} has invalid url.`, cookie };
+    }
+  }
+  let normalizedDomain;
+  if (hasDomain) {
+    normalizedDomain = String(cookie.domain).trim().toLowerCase();
+    if (!/^\.?[a-z0-9.-]+$/.test(normalizedDomain)) {
+      return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+    }
+    if (normalizedDomain.includes("..")) {
+      return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+    }
+  }
+  const normalizedPath = typeof cookie.path === "string" ? cookie.path.trim() : void 0;
+  if (typeof normalizedPath === "string" && !normalizedPath.startsWith("/")) {
+    return { valid: false, reason: `Cookie ${name} path must start with '/'.`, cookie };
+  }
+  if (typeof cookie.expires !== "undefined") {
+    if (!Number.isFinite(cookie.expires)) {
+      return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+    }
+    if (cookie.expires < -1) {
+      return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+    }
+  }
+  if (cookie.sameSite === "None" && cookie.secure !== true) {
+    return { valid: false, reason: `Cookie ${name} with SameSite=None must set secure=true.`, cookie };
+  }
+  const normalizedCookie = {
+    name,
+    value,
+    ...typeof cookie.expires === "number" ? { expires: cookie.expires } : {},
+    ...typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {},
+    ...typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {},
+    ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+  };
+  if (normalizedDomain) {
+    normalizedCookie.domain = normalizedDomain;
+    normalizedCookie.path = normalizedPath ?? "/";
+  } else if (normalizedUrl) {
+    normalizedCookie.url = normalizedUrl;
+  }
+  return {
+    valid: true,
+    reason: "",
+    cookie: normalizedCookie
+  };
+}
+function createCookieImportTool(deps) {
+  return tool36({
+    description: "Import validated cookies into the current session context.",
+    args: {
+      sessionId: z36.string().describe("Session id"),
+      cookies: z36.array(z36.object({
+        name: z36.string().min(1),
+        value: z36.string(),
+        url: z36.string().optional(),
+        domain: z36.string().optional(),
+        path: z36.string().optional(),
+        expires: z36.number().optional(),
+        httpOnly: z36.boolean().optional(),
+        secure: z36.boolean().optional(),
+        sameSite: z36.enum(["Strict", "Lax", "None"]).optional()
+      })).min(1).describe("Cookies to import"),
+      strict: z36.boolean().optional().describe("Reject on first invalid cookie (default true)"),
+      requestId: z36.string().optional().describe("Optional trace request id")
+    },
+    async execute(args) {
+      try {
+        const strict = args.strict ?? true;
+        const requestId = args.requestId ?? createRequestId();
+        const manager = deps.manager;
+        const normalized = [];
+        const rejected = [];
+        args.cookies.forEach((cookie, index) => {
+          const validation = validateCookieRecord(cookie);
+          if (!validation.valid) {
+            rejected.push({ index, reason: validation.reason });
+            return;
+          }
+          normalized.push(validation.cookie);
+        });
+        if (typeof manager.cookieImport === "function") {
+          return ok(await manager.cookieImport(args.sessionId, normalized, strict, requestId));
+        }
+        if (strict && rejected.length > 0) {
+          return failure(`Cookie import rejected ${rejected.length} entries.`, "cookie_import_failed");
+        }
+        if (normalized.length > 0) {
+          await deps.manager.withPage(args.sessionId, null, async (page) => {
+            await page.context().addCookies(normalized);
+            return void 0;
+          });
+        }
+        return ok({
+          requestId,
+          imported: normalized.length,
+          rejected
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "cookie_import_failed");
+      }
+    }
+  });
+}
+
+// src/tools/cookie_list.ts
+import { tool as tool37 } from "@opencode-ai/plugin";
+var z37 = tool37.schema;
+function normalizeCookieUrls(urls) {
+  if (!urls || urls.length === 0) {
+    return void 0;
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of urls) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error("Cookie list urls must be non-empty strings.");
+    }
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(trimmed);
+    } catch {
+      throw new Error(`Cookie list url is invalid: ${trimmed}`);
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw new Error(`Cookie list url must be http(s): ${trimmed}`);
+    }
+    const normalizedUrl = parsedUrl.toString();
+    if (seen.has(normalizedUrl)) {
+      continue;
+    }
+    seen.add(normalizedUrl);
+    normalized.push(normalizedUrl);
+  }
+  return normalized;
+}
+function createCookieListTool(deps) {
+  return tool37({
+    description: "List cookies in the current session context with optional URL filtering.",
+    args: {
+      sessionId: z37.string().describe("Session id"),
+      urls: z37.array(z37.string().min(1)).optional().describe("Optional URL filters for cookie scoping"),
+      requestId: z37.string().optional().describe("Optional trace request id")
+    },
+    async execute(args) {
+      try {
+        const manager = deps.manager;
+        const normalizedUrls = normalizeCookieUrls(args.urls);
+        const requestId = args.requestId ?? createRequestId();
+        if (typeof manager.cookieList === "function") {
+          return ok(await manager.cookieList(args.sessionId, normalizedUrls, requestId));
+        }
+        const cookies = await deps.manager.withPage(
+          args.sessionId,
+          null,
+          async (page) => {
+            const listed = normalizedUrls ? await page.context().cookies(normalizedUrls) : await page.context().cookies();
+            return listed.map((cookie) => ({
+              name: cookie.name,
+              value: cookie.value,
+              domain: cookie.domain,
+              path: cookie.path,
+              expires: cookie.expires,
+              httpOnly: cookie.httpOnly,
+              secure: cookie.secure,
+              ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+            }));
+          }
+        );
+        return ok({
+          requestId,
+          cookies,
+          count: cookies.length
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "cookie_list_failed");
+      }
+    }
+  });
+}
+
+// src/tools/macro_resolve.ts
+import { tool as tool38 } from "@opencode-ai/plugin";
+var z38 = tool38.schema;
+async function loadMacroRuntime() {
+  try {
+    const module = await import("./macros-NUBRM44Y.js");
+    return module;
+  } catch {
+    return null;
+  }
+}
+function parseFallbackMacro(expression, defaultProvider) {
+  const raw = expression.trim();
+  if (!raw.startsWith("@")) {
+    throw new Error("Macro expressions must start with '@'");
+  }
+  const body = raw.slice(1).trim();
+  if (!body) {
+    throw new Error("Macro name is required");
+  }
+  const openParen = body.indexOf("(");
+  const closeParen = body.endsWith(")") ? body.length - 1 : -1;
+  const macroName = openParen >= 0 ? body.slice(0, openParen).trim() : body;
+  const argsBody = openParen >= 0 && closeParen > openParen ? body.slice(openParen + 1, closeParen).trim() : "";
+  const positional = argsBody ? argsBody.split(",").map((part) => part.trim().replace(/^['\"]|['\"]$/g, "")).filter(Boolean) : [];
+  const query = positional[0] ?? macroName;
+  const provider = defaultProvider ?? "web/default";
+  return {
+    action: {
+      source: "web",
+      operation: "search",
+      input: {
+        query,
+        limit: 10,
+        providerId: provider
+      }
+    },
+    provenance: {
+      macro: macroName,
+      provider,
+      resolvedQuery: query,
+      pack: "fallback",
+      args: {
+        positional,
+        named: {}
+      }
+    }
+  };
+}
+function createMacroResolveTool(deps) {
+  return tool38({
+    description: "Resolve a macro expression to a provider action with provenance metadata.",
+    args: {
+      expression: z38.string().min(2).describe('Macro expression, e.g. @web.search("query")'),
+      defaultProvider: z38.string().optional().describe("Default provider fallback"),
+      includeCatalog: z38.boolean().optional().describe("Include available runtime macro names"),
+      execute: z38.boolean().optional().describe("Execute the resolved provider action and include execution payload")
+    },
+    async execute(args) {
+      try {
+        const runtime = await loadMacroRuntime();
+        const registry = runtime?.createDefaultMacroRegistry?.();
+        let resolvedRuntime = "fallback";
+        let resolution;
+        let catalog;
+        if (registry) {
+          resolvedRuntime = "macros";
+          resolution = await registry.resolve(args.expression, {
+            defaultProvider: args.defaultProvider
+          });
+          catalog = args.includeCatalog ? registry.list().map((entry) => ({
+            name: entry.name,
+            pack: entry.pack,
+            description: entry.description
+          })) : void 0;
+        } else {
+          resolution = parseFallbackMacro(args.expression, args.defaultProvider);
+        }
+        if (!args.execute) {
+          return ok({
+            runtime: resolvedRuntime,
+            resolution,
+            ...catalog ? { catalog } : {}
+          });
+        }
+        const runtimeConfig = deps.config?.get?.();
+        const providerRuntime = deps.providerRuntime ?? createConfiguredProviderRuntime({
+          config: runtimeConfig,
+          manager: deps.manager,
+          browserFallbackPort: deps.browserFallbackPort
+        });
+        const execution = shapeExecutionPayload(
+          await executeMacroResolution(resolution, providerRuntime)
+        );
+        return ok({
+          runtime: resolvedRuntime,
+          resolution,
+          ...catalog ? { catalog } : {},
+          execution
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "macro_resolve_failed");
+      }
+    }
+  });
+}
+
+// src/tools/clone_page.ts
+import { tool as tool39 } from "@opencode-ai/plugin";
+var z39 = tool39.schema;
+function createClonePageTool(deps) {
+  return tool39({
     description: "Export the active page as a React component and CSS bundle.",
     args: {
-      sessionId: z35.string().describe("Active browser session id")
+      sessionId: z39.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -1571,14 +2156,14 @@ function createClonePageTool(deps) {
 }
 
 // src/tools/clone_component.ts
-import { tool as tool36 } from "@opencode-ai/plugin";
-var z36 = tool36.schema;
+import { tool as tool40 } from "@opencode-ai/plugin";
+var z40 = tool40.schema;
 function createCloneComponentTool(deps) {
-  return tool36({
+  return tool40({
     description: "Export a selected element subtree as a React component and CSS bundle.",
     args: {
-      sessionId: z36.string().describe("Active browser session id"),
-      ref: z36.string().describe("Element ref from snapshot")
+      sessionId: z40.string().describe("Active browser session id"),
+      ref: z40.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
@@ -1592,13 +2177,13 @@ function createCloneComponentTool(deps) {
 }
 
 // src/tools/perf.ts
-import { tool as tool37 } from "@opencode-ai/plugin";
-var z37 = tool37.schema;
+import { tool as tool41 } from "@opencode-ai/plugin";
+var z41 = tool41.schema;
 function createPerfTool(deps) {
-  return tool37({
+  return tool41({
     description: "Fetch lightweight performance metrics from the active page.",
     args: {
-      sessionId: z37.string().describe("Active browser session id")
+      sessionId: z41.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -1612,14 +2197,14 @@ function createPerfTool(deps) {
 }
 
 // src/tools/screenshot.ts
-import { tool as tool38 } from "@opencode-ai/plugin";
-var z38 = tool38.schema;
+import { tool as tool42 } from "@opencode-ai/plugin";
+var z42 = tool42.schema;
 function createScreenshotTool(deps) {
-  return tool38({
+  return tool42({
     description: "Capture a screenshot of the active page.",
     args: {
-      sessionId: z38.string().describe("Active browser session id"),
-      path: z38.string().optional().describe("Optional output file path")
+      sessionId: z42.string().describe("Active browser session id"),
+      path: z42.string().optional().describe("Optional output file path")
     },
     async execute(args) {
       try {
@@ -1633,23 +2218,23 @@ function createScreenshotTool(deps) {
 }
 
 // src/tools/annotate.ts
-import { tool as tool39 } from "@opencode-ai/plugin";
-var z39 = tool39.schema;
-var screenshotModeSchema = z39.enum(["visible", "full", "none"]);
-var transportSchema = z39.enum(["auto", "direct", "relay"]);
+import { tool as tool43 } from "@opencode-ai/plugin";
+var z43 = tool43.schema;
+var screenshotModeSchema = z43.enum(["visible", "full", "none"]);
+var transportSchema = z43.enum(["auto", "direct", "relay"]);
 function createAnnotateTool(deps) {
-  return tool39({
+  return tool43({
     description: "Request interactive annotations via direct (CDP) or relay transport.",
     args: {
-      sessionId: z39.string().describe("Session id"),
+      sessionId: z43.string().describe("Session id"),
       transport: transportSchema.optional().describe("auto | direct | relay (default: auto)"),
-      targetId: z39.string().optional().describe("Optional target id for direct mode"),
-      tabId: z39.number().int().optional().describe("Optional Chrome tab id for relay mode"),
-      url: z39.string().optional().describe("Optional URL to open before annotating"),
+      targetId: z43.string().optional().describe("Optional target id for direct mode"),
+      tabId: z43.number().int().optional().describe("Optional Chrome tab id for relay mode"),
+      url: z43.string().optional().describe("Optional URL to open before annotating"),
       screenshotMode: screenshotModeSchema.optional().describe("visible | full | none (default: visible)"),
-      debug: z39.boolean().optional().describe("Include debug metadata"),
-      context: z39.string().optional().describe("Optional context for the annotator"),
-      timeoutMs: z39.number().int().optional().describe("Timeout in milliseconds")
+      debug: z43.boolean().optional().describe("Include debug metadata"),
+      context: z43.string().optional().describe("Optional context for the annotator"),
+      timeoutMs: z43.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
@@ -1689,10 +2274,186 @@ function createAnnotateTool(deps) {
   });
 }
 
+// src/tools/research_run.ts
+import { tool as tool44 } from "@opencode-ai/plugin";
+
+// src/tools/workflow-runtime.ts
+var resolveProviderRuntime = (deps) => {
+  if (deps.providerRuntime) {
+    return deps.providerRuntime;
+  }
+  return createConfiguredProviderRuntime({
+    config: deps.config?.get?.(),
+    manager: deps.manager,
+    browserFallbackPort: deps.browserFallbackPort
+  });
+};
+
+// src/tools/research_run.ts
+var z44 = tool44.schema;
+var sourceSelectionSchema = z44.enum(["auto", "web", "community", "social", "shopping", "all"]);
+var sourceSchema = z44.enum(["web", "community", "social", "shopping"]);
+var modeSchema = z44.enum(["compact", "json", "md", "context", "path"]);
+var cookiePolicySchema = z44.enum(["off", "auto", "required"]);
+function createResearchRunTool(deps) {
+  return tool44({
+    description: "Run cross-source research with strict timebox and artifact outputs.",
+    args: {
+      topic: z44.string().min(1).describe("Research topic"),
+      days: z44.number().int().positive().optional().describe("Timebox in days"),
+      from: z44.string().optional().describe("ISO start date"),
+      to: z44.string().optional().describe("ISO end date"),
+      sourceSelection: sourceSelectionSchema.optional().describe("auto|web|community|social|shopping|all"),
+      sources: z44.array(sourceSchema).optional().describe("Explicit source list"),
+      mode: modeSchema.optional().describe("compact|json|md|context|path"),
+      includeEngagement: z44.boolean().optional().describe("Include engagement enrichment"),
+      limitPerSource: z44.number().int().positive().optional().describe("Result limit per source"),
+      outputDir: z44.string().optional().describe("Optional artifact output directory"),
+      ttlHours: z44.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      useCookies: z44.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      cookiePolicyOverride: cookiePolicySchema.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = resolveProviderRuntime(deps);
+        const result = await runResearchWorkflow(runtime, {
+          topic: args.topic,
+          days: args.days,
+          from: args.from,
+          to: args.to,
+          sourceSelection: args.sourceSelection,
+          sources: args.sources,
+          mode: args.mode ?? "compact",
+          includeEngagement: args.includeEngagement,
+          limitPerSource: args.limitPerSource,
+          outputDir: args.outputDir,
+          ttlHours: args.ttlHours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "research_run_failed");
+      }
+    }
+  });
+}
+
+// src/tools/shopping_run.ts
+import { tool as tool45 } from "@opencode-ai/plugin";
+var z45 = tool45.schema;
+var sortSchema = z45.enum(["best_deal", "lowest_price", "highest_rating", "fastest_shipping"]);
+var modeSchema2 = z45.enum(["compact", "json", "md", "context", "path"]);
+var cookiePolicySchema2 = z45.enum(["off", "auto", "required"]);
+function createShoppingRunTool(deps) {
+  return tool45({
+    description: "Run shopping/deal intelligence across shopping providers.",
+    args: {
+      query: z45.string().min(1).describe("Shopping query"),
+      providers: z45.array(z45.string()).optional().describe("Optional provider allow-list"),
+      budget: z45.number().positive().optional().describe("Optional budget amount"),
+      region: z45.string().optional().describe("Region hint"),
+      sort: sortSchema.optional().describe("best_deal|lowest_price|highest_rating|fastest_shipping"),
+      mode: modeSchema2.optional().describe("compact|json|md|context|path"),
+      outputDir: z45.string().optional().describe("Optional artifact output directory"),
+      ttlHours: z45.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      useCookies: z45.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      cookiePolicyOverride: cookiePolicySchema2.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = resolveProviderRuntime(deps);
+        const result = await runShoppingWorkflow(runtime, {
+          query: args.query,
+          providers: args.providers,
+          budget: args.budget,
+          region: args.region,
+          sort: args.sort,
+          mode: args.mode ?? "compact",
+          outputDir: args.outputDir,
+          ttlHours: args.ttlHours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "shopping_run_failed");
+      }
+    }
+  });
+}
+
+// src/tools/product_video_run.ts
+import { tool as tool46 } from "@opencode-ai/plugin";
+var z46 = tool46.schema;
+var cookiePolicySchema3 = z46.enum(["off", "auto", "required"]);
+async function captureScreenshotBuffer(deps, url) {
+  let sessionId = null;
+  try {
+    const launched = await deps.manager.launch({
+      headless: true,
+      startUrl: url
+    });
+    sessionId = launched.sessionId;
+    const screenshot = await deps.manager.screenshot(sessionId);
+    if (typeof screenshot.base64 === "string" && screenshot.base64.length > 0) {
+      return Buffer.from(screenshot.base64, "base64");
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (sessionId) {
+      await deps.manager.disconnect(sessionId, true).catch(() => {
+      });
+    }
+  }
+}
+function createProductVideoRunTool(deps) {
+  return tool46({
+    description: "Collect a product presentation asset pack for video/UGC workflows.",
+    args: {
+      product_url: z46.string().optional().describe("Product URL"),
+      product_name: z46.string().optional().describe("Product name"),
+      provider_hint: z46.string().optional().describe("Optional provider hint"),
+      include_screenshots: z46.boolean().optional().describe("Include screenshots (default true)"),
+      include_all_images: z46.boolean().optional().describe("Include all discovered images (default true)"),
+      include_copy: z46.boolean().optional().describe("Include product copy extraction (default true)"),
+      output_dir: z46.string().optional().describe("Optional output directory"),
+      ttl_hours: z46.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      useCookies: z46.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      cookiePolicyOverride: cookiePolicySchema3.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = resolveProviderRuntime(deps);
+        const includeScreenshots = args.include_screenshots ?? true;
+        const result = await runProductVideoWorkflow(runtime, {
+          product_url: args.product_url,
+          product_name: args.product_name,
+          provider_hint: args.provider_hint,
+          include_screenshots: includeScreenshots,
+          include_all_images: args.include_all_images,
+          include_copy: args.include_copy,
+          output_dir: args.output_dir,
+          ttl_hours: args.ttl_hours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        }, {
+          captureScreenshot: includeScreenshots ? async (url) => captureScreenshotBuffer(deps, url) : void 0
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "product_video_run_failed");
+      }
+    }
+  });
+}
+
 // src/tools/skill_list.ts
-import { tool as tool40 } from "@opencode-ai/plugin";
+import { tool as tool47 } from "@opencode-ai/plugin";
 function createSkillListTool(deps) {
-  return tool40({
+  return tool47({
     description: "List available skills from OpenCode skill directories (compatibility wrapper)",
     args: {},
     async execute() {
@@ -1708,14 +2469,14 @@ function createSkillListTool(deps) {
 }
 
 // src/tools/skill_load.ts
-import { tool as tool41 } from "@opencode-ai/plugin";
-var z40 = tool41.schema;
+import { tool as tool48 } from "@opencode-ai/plugin";
+var z47 = tool48.schema;
 function createSkillLoadTool(deps) {
-  return tool41({
+  return tool48({
     description: "Load a specific skill by name from OpenCode skill directories (compatibility wrapper)",
     args: {
-      name: z40.string().describe("Name of the skill to load (e.g., 'login-automation', 'form-testing')"),
-      topic: z40.string().optional().describe("Optional topic to filter the skill content")
+      name: z47.string().describe("Name of the skill to load (e.g., 'opendevbrowser-login-automation', 'opendevbrowser-form-testing')"),
+      topic: z47.string().optional().describe("Optional topic to filter the skill content")
     },
     async execute(args) {
       try {
@@ -1779,6 +2540,13 @@ function createTools(deps) {
     opendevbrowser_prompting_guide: wrap(createPromptingGuideTool(deps)),
     opendevbrowser_console_poll: wrap(createConsolePollTool(deps)),
     opendevbrowser_network_poll: wrap(createNetworkPollTool(deps)),
+    opendevbrowser_debug_trace_snapshot: wrap(createDebugTraceSnapshotTool(deps)),
+    opendevbrowser_cookie_import: wrap(createCookieImportTool(deps)),
+    opendevbrowser_cookie_list: wrap(createCookieListTool(deps)),
+    opendevbrowser_macro_resolve: wrap(createMacroResolveTool(deps)),
+    opendevbrowser_research_run: wrap(createResearchRunTool(deps)),
+    opendevbrowser_shopping_run: wrap(createShoppingRunTool(deps)),
+    opendevbrowser_product_video_run: wrap(createProductVideoRunTool(deps)),
     opendevbrowser_clone_page: wrap(createClonePageTool(deps)),
     opendevbrowser_clone_component: wrap(createCloneComponentTool(deps)),
     opendevbrowser_perf: wrap(createPerfTool(deps)),
@@ -1797,6 +2565,8 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   let manager = core.manager;
   let runner = core.runner;
   let annotationManager = core.annotationManager;
+  let providerRuntime = core.providerRuntime;
+  let browserFallbackPort = core.browserFallbackPort;
   let hubStop = null;
   let daemonClient = null;
   const skillNudgeState = createSkillNudgeState();
@@ -1815,6 +2585,8 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
     runner,
     config: configStore,
     skills,
+    providerRuntime,
+    browserFallbackPort,
     relay,
     getExtensionPath
   };
@@ -1827,9 +2599,17 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
     annotationManager.setRelay(relay);
     annotationManager.setBrowserManager(manager);
     runner = new ScriptRunner(manager);
+    browserFallbackPort = createBrowserFallbackPort(manager);
+    providerRuntime = createConfiguredProviderRuntime({
+      config: configStore.get(),
+      manager,
+      browserFallbackPort
+    });
     toolDeps.manager = manager;
     toolDeps.relay = relay;
     toolDeps.runner = runner;
+    toolDeps.providerRuntime = providerRuntime;
+    toolDeps.browserFallbackPort = browserFallbackPort;
   };
   const ensureHub = async () => {
     const currentConfig = configStore.get();