@vforsh/argus 0.1.14 → 0.1.16

package/dist/argus.js

@@ -2130,7 +2130,7 @@ var {
 // package.json
 var package_default = {
   name: "@vforsh/argus",
-  version: "0.1.14",
+  version: "0.1.16",
   repository: {
     type: "git",
     url: "git+https://github.com/vforsh/argus.git",
@@ -2158,12 +2158,13 @@ var package_default = {
   dependencies: {
     "@vforsh/argus-plugin-api": "workspace:*",
     commander: "14.0.2",
+    esbuild: "0.25.12",
     prettier: "3.7.4"
   },
   scripts: {
     clean: "node ../../scripts/clean-dist.mjs",
     build: "npm run clean && tsc -b && bun run bundle",
-    bundle: "bun build dist/bin.js --outfile dist/argus.js --target node",
+    bundle: "bun build dist/bin.js --outfile dist/argus.js --target node --external esbuild",
     typecheck: "tsc -b --pretty false",
     "chrome:start": "bun src/bin.ts chrome start"
   }
@@ -2172,7 +2173,7 @@ var package_default = {
 // dist/cli/program.js
 function createProgram() {
   const program2 = new Command;
-  program2.name("argus").description("Argus CLI for local watcher servers").version(package_default.version).configureOutput({
+  program2.name("argus").description("Argus CLI for local watcher servers").version(package_default.version).option("--plugin <specifier>", "Load an extra CLI plugin for this invocation", collectPluginOption, []).configureOutput({
     outputError: (str, write) => write(str)
   }).showSuggestionAfterError(true).exitOverride((error) => {
     if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
@@ -2183,6 +2184,7 @@ function createProgram() {
   });
   return program2;
 }
+var collectPluginOption = (value, previous) => [...previous, value];
 
 // ../argus-core/dist/protocol/logs.js
 var formatLogLevelTag = (level) => {
@@ -3311,11 +3313,20 @@ function writeResolveError(resolved, output) {
 
 // dist/cli/defineWatcherCommand.js
 var DEFAULT_TIMEOUT_MS = 30000;
+var requestWatcherCommandJson = async (input, output) => {
+  const result = await requestWatcherJson(input);
+  if (!result.ok) {
+    writeRequestError(result, output);
+    return null;
+  }
+  return result;
+};
+var requestWatcherCommandAction = requestWatcherAction;
 var defineWatcherCommand = (spec) => async (id, ...rest) => {
   const tail = rest.length - 1;
   const options = rest[tail];
   const args = rest.slice(0, tail);
-  const output = createOutput(options);
+  const output = createOutput({ ...options, json: options.json === true || spec.isJson?.(options) === true });
   const plan = await spec.build(args, options, output);
   if (plan == null)
     return;
@@ -4368,20 +4379,15 @@ var loadAuthStateSnapshot = async (inputPath) => {
   return parseAuthStateSnapshot(parsed, `auth state ${source}`);
 };
 var requestAuthStateSnapshot = async (id, input, output) => {
-  const result = await requestWatcherJson({
+  return requestWatcherCommandJson({
     id,
     path: "/auth/state",
     query: buildStateQuery(input),
     timeoutMs: 1e4
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return null;
-  }
-  return result;
+  }, output);
 };
 var loadAuthStateIntoWatcher = async (id, snapshot, input, output) => {
-  const result = await requestWatcherAction({
+  const result = await requestWatcherCommandAction({
     id,
     path: "/auth/state/load",
     method: "POST",
@@ -6427,19 +6433,62 @@ var handle11 = (_req, res, url, ctx) => {
   respondJson(res, response);
 };
 
+// ../argus-watcher/dist/http/routes/defineRoute.js
+var defineJsonRoute = (input) => ({
+  method: input.method,
+  path: input.path,
+  extensionOnly: input.extensionOnly,
+  handler: async (req, res, url, ctx) => {
+    const shouldReadBody = input.bodySchema != null || input.parseBody === true;
+    const rawBody = shouldReadBody ? await readJsonBody(req, res) : undefined;
+    if (shouldReadBody && rawBody == null) {
+      return;
+    }
+    const parsedBody = input.bodySchema?.parse(rawBody);
+    if (parsedBody && !parsedBody.ok) {
+      return respondInvalidBody(res, formatProtocolValidationIssues(parsedBody.issues));
+    }
+    if (input.endpoint) {
+      emitRequest(ctx, res, input.endpoint);
+    }
+    try {
+      const response = await input.handle({
+        req,
+        res,
+        url,
+        ctx,
+        body: parsedBody?.value ?? rawBody
+      });
+      if (response) {
+        respondJson(res, response);
+      }
+    } catch (error) {
+      if (input.handleError?.(res, error)) {
+        return;
+      }
+      respondError(res, error);
+    }
+  }
+});
+
 // ../argus-watcher/dist/http/routes/postNetClear.js
-var handle12 = (_req, res, _url, ctx) => {
-  if (!ctx.netBuffer) {
-    return respondJson(res, { ok: false, error: { code: "net_disabled", message: "Network capture is disabled for this watcher" } }, 400);
+var handle12 = defineJsonRoute({
+  method: "POST",
+  path: "/net/clear",
+  handle: ({ res, ctx }) => {
+    if (!ctx.netBuffer) {
+      respondJson(res, { ok: false, error: { code: "net_disabled", message: "Network capture is disabled for this watcher" } }, 400);
+      return;
+    }
+    emitRequest(ctx, res, "net/clear");
+    const realtimeCleared = ctx.realtimeNetBuffer?.clear() ?? 0;
+    const response = {
+      ok: true,
+      cleared: ctx.netBuffer.clear() + realtimeCleared
+    };
+    return response;
   }
-  emitRequest(ctx, res, "net/clear");
-  const realtimeCleared = ctx.realtimeNetBuffer?.clear() ?? 0;
-  const response = {
-    ok: true,
-    cleared: ctx.netBuffer.clear() + realtimeCleared
-  };
-  respondJson(res, response);
-};
+}).handler;
 
 // ../argus-watcher/dist/cdp/auth.js
 var inspectAuthCookies = async (session, options) => {
@@ -7304,23 +7353,19 @@ var handle18 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/postScreenshot.js
-var handle19 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  const validationError = validateScreenshotRequest(payload);
-  if (validationError) {
-    return respondInvalidBody(res, validationError);
-  }
-  emitRequest(ctx, res, "screenshot");
-  try {
-    const response = await ctx.screenshotter.capture(payload);
-    respondJson(res, response);
-  } catch (error) {
-    respondError(res, error);
+var handle19 = defineJsonRoute({
+  method: "POST",
+  path: "/screenshot",
+  parseBody: true,
+  handle: async ({ res, ctx, body: payload }) => {
+    const validationError = validateScreenshotRequest(payload);
+    if (validationError) {
+      return respondInvalidBody(res, validationError);
+    }
+    emitRequest(ctx, res, "screenshot");
+    return ctx.screenshotter.capture(payload);
   }
-};
+}).handler;
 var validateScreenshotRequest = (payload) => {
   if (payload.selector != null && (typeof payload.selector !== "string" || !payload.selector.trim())) {
     return "selector must be a non-empty string";
@@ -7825,29 +7870,25 @@ var countNodes = (nodes) => {
 };
 
 // ../argus-watcher/dist/http/routes/postSnapshot.js
-var handle20 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  if (payload.selector != null && (typeof payload.selector !== "string" || payload.selector.trim() === "")) {
-    return respondInvalidBody(res, "selector must be a non-empty string");
-  }
-  if (payload.depth != null && (!Number.isFinite(payload.depth) || payload.depth < 0 || !Number.isInteger(payload.depth))) {
-    return respondInvalidBody(res, "depth must be a non-negative integer");
-  }
-  emitRequest(ctx, res, "snapshot");
-  try {
-    const response = await fetchAccessibilitySnapshot(ctx.cdpSession, {
+var handle20 = defineJsonRoute({
+  method: "POST",
+  path: "/snapshot",
+  parseBody: true,
+  handle: async ({ res, ctx, body: payload }) => {
+    if (payload.selector != null && (typeof payload.selector !== "string" || payload.selector.trim() === "")) {
+      return respondInvalidBody(res, "selector must be a non-empty string");
+    }
+    if (payload.depth != null && (!Number.isFinite(payload.depth) || payload.depth < 0 || !Number.isInteger(payload.depth))) {
+      return respondInvalidBody(res, "depth must be a non-negative integer");
+    }
+    emitRequest(ctx, res, "snapshot");
+    return fetchAccessibilitySnapshot(ctx.cdpSession, {
       selector: payload.selector,
       depth: payload.depth,
       interactive: payload.interactive ?? false
     }, ctx.elementRefs);
-    respondJson(res, response);
-  } catch (error) {
-    respondError(res, error);
   }
-};
+}).handler;
 
 // ../argus-watcher/dist/http/routes/domSelectorRoute.js
 var readDomTargetPayload = async (req, res) => {
@@ -8741,43 +8782,6 @@ var route = defineDomTargetRoute({
   }
 });
 
-// ../argus-watcher/dist/http/routes/defineRoute.js
-var defineJsonRoute = (input) => ({
-  method: input.method,
-  path: input.path,
-  extensionOnly: input.extensionOnly,
-  handler: async (req, res, url, ctx) => {
-    const rawBody = input.bodySchema ? await readJsonBody(req, res) : undefined;
-    if (input.bodySchema && rawBody == null) {
-      return;
-    }
-    const parsedBody = input.bodySchema?.parse(rawBody);
-    if (parsedBody && !parsedBody.ok) {
-      return respondInvalidBody(res, formatProtocolValidationIssues(parsedBody.issues));
-    }
-    if (input.endpoint) {
-      emitRequest(ctx, res, input.endpoint);
-    }
-    try {
-      const response = await input.handle({
-        req,
-        res,
-        url,
-        ctx,
-        body: parsedBody?.value
-      });
-      if (response) {
-        respondJson(res, response);
-      }
-    } catch (error) {
-      if (input.handleError?.(res, error)) {
-        return;
-      }
-      respondError(res, error);
-    }
-  }
-});
-
 // ../argus-watcher/dist/http/routes/postDomClick.js
 var route2 = defineJsonRoute({
   method: "POST",
@@ -9427,78 +9431,75 @@ var handle37 = async (req, res, _url, ctx) => {
 };
 
 // ../argus-watcher/dist/http/routes/getThrottle.js
-var handle38 = (_req, res, _url, ctx) => {
-  emitRequest(ctx, res, "throttle");
-  const status = ctx.throttleController.getStatus({ attached: ctx.getCdpStatus().attached });
-  respondJson(res, status);
-};
+var handle38 = defineJsonRoute({
+  method: "GET",
+  path: "/throttle",
+  endpoint: "throttle",
+  handle: ({ ctx }) => ctx.throttleController.getStatus({ attached: ctx.getCdpStatus().attached })
+}).handler;
 
 // ../argus-watcher/dist/http/routes/postThrottle.js
-var handle39 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  const validActions = ["set", "clear"];
-  const action = payload.action;
-  if (!action || !validActions.includes(action)) {
-    return respondInvalidBody(res, `action must be one of: ${validActions.join(", ")}`);
-  }
-  emitRequest(ctx, res, "throttle");
-  const session = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
-  if (action === "clear") {
-    try {
-      const response = await ctx.throttleController.clearDesired(session);
-      respondJson(res, response);
-    } catch (error) {
-      respondError(res, error);
+var handle39 = defineJsonRoute({
+  method: "POST",
+  path: "/throttle",
+  parseBody: true,
+  handle: async ({ res, ctx, body: payload }) => {
+    const validActions = ["set", "clear"];
+    const action = payload.action;
+    if (!action || !validActions.includes(action)) {
+      return respondInvalidBody(res, `action must be one of: ${validActions.join(", ")}`);
+    }
+    emitRequest(ctx, res, "throttle");
+    const session = ctx.cdpSession.isAttached() ? ctx.cdpSession : null;
+    if (action === "clear") {
+      return ctx.throttleController.clearDesired(session);
     }
-    return;
-  }
-  const setPayload = payload;
-  if (typeof setPayload.rate !== "number" || !Number.isFinite(setPayload.rate) || setPayload.rate < 1) {
-    return respondInvalidBody(res, "rate must be a finite number >= 1");
-  }
-  try {
-    const response = await ctx.throttleController.setDesired(setPayload.rate, session);
-    respondJson(res, response);
-  } catch (error) {
-    respondError(res, error);
+    const setPayload = payload;
+    if (typeof setPayload.rate !== "number" || !Number.isFinite(setPayload.rate) || setPayload.rate < 1) {
+      return respondInvalidBody(res, "rate must be a finite number >= 1");
+    }
+    return ctx.throttleController.setDesired(setPayload.rate, session);
   }
-};
+}).handler;
 
 // ../argus-watcher/dist/http/routes/getDialog.js
-var handle40 = (_req, res, _url, ctx) => {
-  emitRequest(ctx, res, "dialog/status");
-  const response = {
-    ok: true,
-    dialog: ctx.getDialog()
-  };
-  respondJson(res, response);
-};
+var handle40 = defineJsonRoute({
+  method: "GET",
+  path: "/dialog",
+  endpoint: "dialog/status",
+  handle: ({ ctx }) => {
+    const response = {
+      ok: true,
+      dialog: ctx.getDialog()
+    };
+    return response;
+  }
+}).handler;
 
 // ../argus-watcher/dist/http/routes/postDialog.js
-var handle41 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  emitRequest(ctx, res, "dialog/handle");
-  const action = payload.action;
-  if (action !== "accept" && action !== "dismiss") {
-    respondInvalidBody(res, 'Dialog action must be "accept" or "dismiss"');
-    return;
-  }
-  const dialog = ctx.getDialog();
-  if (!dialog) {
-    respondJson(res, { ok: false, error: { message: "No active browser dialog", code: "no_active_dialog" } }, 409);
-    return;
-  }
-  if (payload.promptText != null && dialog.type !== "prompt") {
-    respondJson(res, { ok: false, error: { message: "Prompt text can only be sent to prompt dialogs", code: "dialog_not_prompt" } }, 409);
-    return;
-  }
-  try {
+var handle41 = defineJsonRoute({
+  method: "POST",
+  path: "/dialog",
+  parseBody: true,
+  endpoint: "dialog/handle",
+  handle: async ({ res, ctx, body: payload }) => {
+    const action = payload.action;
+    if (action !== "accept" && action !== "dismiss") {
+      respondInvalidBody(res, 'Dialog action must be "accept" or "dismiss"');
+      return;
+    }
+    const dialog = ctx.getDialog();
+    if (!dialog) {
+      respondJson(res, { ok: false, error: { message: "No active browser dialog", code: "no_active_dialog" } }, 409);
+      return;
+    }
+    if (payload.promptText != null && dialog.type !== "prompt") {
+      respondJson(res, {
+        ok: false,
+        error: { message: "Prompt text can only be sent to prompt dialogs", code: "dialog_not_prompt" }
+      }, 409);
+      return;
+    }
     await ctx.pageCdpSession.sendAndWait("Page.handleJavaScriptDialog", {
       accept: action === "accept",
       promptText: payload.promptText
@@ -9508,36 +9509,30 @@ var handle41 = async (req, res, _url, ctx) => {
       action,
       dialog
     };
-    respondJson(res, response);
-  } catch (error) {
-    respondError(res, error);
+    return response;
   }
-};
+}).handler;
 
 // ../argus-watcher/dist/http/routes/postVisibility.js
-var handle42 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  emitRequest(ctx, res, "visibility");
-  const action = payload.action;
-  if (action !== "show" && action !== "hide") {
-    respondInvalidBody(res, 'Visibility action must be "show" or "hide"');
-    return;
-  }
-  const lock = action === "show" ? "shown" : "default";
-  const session = ctx.pageCdpSession;
-  const attached = session.isAttached();
-  try {
+var handle42 = defineJsonRoute({
+  method: "POST",
+  path: "/visibility",
+  parseBody: true,
+  handle: async ({ res, ctx, body: payload }) => {
+    const action = payload.action;
+    if (action !== "show" && action !== "hide") {
+      respondInvalidBody(res, 'Visibility action must be "show" or "hide"');
+      return;
+    }
+    emitRequest(ctx, res, "visibility");
+    const lock = action === "show" ? "shown" : "default";
+    const session = ctx.pageCdpSession;
+    const attached = session.isAttached();
     await ctx.visibilityController.setLock(attached ? session : null, lock);
-  } catch (error) {
-    respondError(res, error);
-    return;
+    const response = { ok: true, attached, state: lock };
+    return response;
   }
-  const response = { ok: true, attached, state: lock };
-  respondJson(res, response);
-};
+}).handler;
 
 // ../argus-watcher/dist/cdp/storage.js
 var storageAccessors = {
@@ -9652,22 +9647,18 @@ var handle43 = createStorageHandler("local");
 var handle44 = createStorageHandler("session");
 
 // ../argus-watcher/dist/http/routes/postReload.js
-var handle45 = async (req, res, _url, ctx) => {
-  const payload = await readJsonBody(req, res);
-  if (!payload) {
-    return;
-  }
-  emitRequest(ctx, res, "reload");
-  try {
+var handle45 = defineJsonRoute({
+  method: "POST",
+  path: "/reload",
+  parseBody: true,
+  endpoint: "reload",
+  handle: async ({ ctx, body: payload }) => {
     await ctx.pageCdpSession.sendAndWait("Page.reload", {
       ignoreCache: payload.ignoreCache ?? false
     });
-    const response = { ok: true };
-    respondJson(res, response);
-  } catch (error) {
-    respondError(res, error);
+    return { ok: true };
   }
-};
+}).handler;
 
 // ../argus-watcher/dist/http/routes/postShutdown.js
 var handle46 = (_req, res, _url, ctx) => {
@@ -11316,6 +11307,7 @@ var createVisibilityController = () => {
 // ../argus-watcher/dist/runtime/watcherSetup.js
 var normalizeWatcherSetup = (options, watcherId) => {
   const sourceMode = options.source ?? "cdp";
+  const extensionRole = options.extensionRole ?? "tab";
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? 0;
   const chrome = options.chrome ?? { host: "127.0.0.1", port: 9222 };
@@ -11359,6 +11351,7 @@ var normalizeWatcherSetup = (options, watcherId) => {
   };
   return {
     sourceMode,
+    extensionRole,
     host,
     port,
     chrome,
@@ -14064,6 +14057,57 @@ var createNativeMessaging = () => {
   };
 };
 
+// ../argus-watcher/dist/native-messaging/control-session-manager.js
+class ControlSessionManager {
+  messaging;
+  pendingTabsRequest = null;
+  constructor(messaging) {
+    this.messaging = messaging;
+    this.messaging.onMessage((message) => {
+      this.handleMessage(message);
+    });
+  }
+  attachTabWatcher(tabId) {
+    this.messaging.send({
+      type: "attach_tab_watcher",
+      tabId
+    });
+  }
+  detachTabWatcher(tabId) {
+    this.messaging.send({
+      type: "detach_tab_watcher",
+      tabId
+    });
+  }
+  async listTabs(filter) {
+    return new Promise((resolve2, reject) => {
+      this.pendingTabsRequest = { resolve: resolve2, reject };
+      this.messaging.send({
+        type: "list_tabs",
+        filter
+      });
+      setTimeout(() => {
+        if (!this.pendingTabsRequest) {
+          return;
+        }
+        this.pendingTabsRequest.reject(new Error("List tabs request timed out"));
+        this.pendingTabsRequest = null;
+      }, 5000);
+    });
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "list_tabs_response":
+        this.handleListTabsResponse(message);
+        return;
+    }
+  }
+  handleListTabsResponse(message) {
+    this.pendingTabsRequest?.resolve(message.tabs);
+    this.pendingTabsRequest = null;
+  }
+}
+
 // ../argus-watcher/dist/native-messaging/session-manager.js
 var nextRequestId = 1;
 
@@ -14073,7 +14117,6 @@ class SessionManager {
   pendingRequests = new Map;
   eventHandlers = new Map;
   events;
-  pendingTabsRequest = null;
   constructor(messaging, events) {
     this.messaging = messaging;
     this.events = events;
@@ -14101,9 +14144,6 @@ class SessionManager {
       case "cookie_query_response":
         this.handleCookieQueryResponse(message);
         break;
-      case "list_tabs_response":
-        this.handleListTabsResponse(message);
-        break;
       case "target_selected":
         this.events.onTargetSelected(message.tabId, message.frameId ?? null);
         break;
@@ -14156,13 +14196,6 @@ class SessionManager {
       pending.resolve(result);
     }
   }
-  handleListTabsResponse(message) {
-    if (this.pendingTabsRequest) {
-      this.pendingTabsRequest.resolve(message.tabs);
-      this.pendingTabsRequest = null;
-    }
-    this.events.onTabsUpdated(message.tabs);
-  }
   createSession(message) {
     const { tabId, url, title, faviconUrl } = message;
     const enabledDomains = new Set;
@@ -14243,22 +14276,6 @@ class SessionManager {
     };
     this.messaging.send(message);
   }
-  async listTabs(filter) {
-    return new Promise((resolve2, reject) => {
-      this.pendingTabsRequest = { resolve: resolve2, reject };
-      const message = {
-        type: "list_tabs",
-        filter
-      };
-      this.messaging.send(message);
-      setTimeout(() => {
-        if (this.pendingTabsRequest) {
-          this.pendingTabsRequest.reject(new Error("List tabs request timed out"));
-          this.pendingTabsRequest = null;
-        }
-      }, 5000);
-    });
-  }
   getSession(tabId) {
     return this.sessions.get(tabId);
   }
@@ -14919,7 +14936,87 @@ var TARGET_RECOVERY_INTERVAL_MS = 500;
 var TARGET_RECOVERY_TIMEOUT_MS = 30000;
 var FRAME_COMMAND_READY_TIMEOUT_MS = 3000;
 var FRAME_COMMAND_READY_POLL_MS = 100;
+var createDetachedSession = (message) => ({
+  isAttached: () => false,
+  sendAndWait: async () => {
+    const error = new Error(message);
+    error.code = "cdp_not_attached";
+    throw error;
+  },
+  onEvent: () => () => {}
+});
+var createControlExtensionSource = (options) => {
+  const { events, watcherId, watcherHost, watcherPort } = options;
+  const messaging = createNativeMessaging();
+  const controlSession = new ControlSessionManager(messaging);
+  const hostInfo = {
+    watcherId: watcherId ?? "extension-control",
+    watcherHost: watcherHost ?? "127.0.0.1",
+    watcherPort: watcherPort ?? 0,
+    watcherPid: process.pid
+  };
+  let stopping = false;
+  messaging.start();
+  messaging.send({ type: "host_ready" });
+  sendHostInfo();
+  events.onStatus({
+    attached: false,
+    target: null,
+    reason: "control_watcher"
+  });
+  messaging.onDisconnect(() => {
+    console.error("[ExtensionControlSource] Extension disconnected");
+    if (!stopping) {
+      events.onStatus({ attached: false, target: null, reason: "extension_disconnected" });
+      events.onDetach?.("extension_disconnected");
+    }
+  });
+  return {
+    session: createDetachedSession("Extension control watcher does not expose a CDP tab session"),
+    syncWatcherInfo: (info) => {
+      hostInfo.watcherId = info.watcherId;
+      hostInfo.watcherHost = info.watcherHost;
+      hostInfo.watcherPort = info.watcherPort;
+      hostInfo.watcherPid = info.watcherPid;
+      sendHostInfo();
+    },
+    stop: async () => {
+      stopping = true;
+      messaging.stop();
+    },
+    listTargets: async () => [],
+    listTabs: async (filter) => await controlSession.listTabs(filter),
+    attachTarget: (targetId) => {
+      controlSession.attachTabWatcher(parseControlTabTarget(targetId, "attach"));
+    },
+    detachTarget: (targetId) => {
+      controlSession.detachTabWatcher(parseControlTabTarget(targetId, "detach"));
+    }
+  };
+  function sendHostInfo() {
+    messaging.send({
+      type: "host_info",
+      watcherId: hostInfo.watcherId,
+      watcherHost: hostInfo.watcherHost,
+      watcherPort: hostInfo.watcherPort,
+      pid: hostInfo.watcherPid
+    });
+  }
+};
+var parseControlTabTarget = (targetId, action) => {
+  const target = parseExtensionTargetId(targetId);
+  if (!target.frameId) {
+    return target.tabId;
+  }
+  if (action === "attach") {
+    throw new Error(`Cannot attach iframe ${target.frameId} from extension-control before tab ${target.tabId} has a tab watcher`);
+  }
+  throw new Error(`Cannot detach iframe ${target.frameId} from extension-control. Detach tab ${target.tabId} instead.`);
+};
 var createExtensionSource = (options) => {
+  if (options.role === "control") {
+    return createControlExtensionSource(options);
+  }
   const { events, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, watcherId, watcherHost, watcherPort } = options;
   const messaging = createNativeMessaging();
   const hostInfo = {
@@ -14958,7 +15055,6 @@ var createExtensionSource = (options) => {
       emitStatus(null, reason);
       events.onDetach?.(reason);
     },
-    onTabsUpdated: () => {},
     onTargetSelected: (tabId, frameId) => {
       const session = currentSession;
       if (!session || session.tabId !== tabId) {
@@ -14998,6 +15094,7 @@ var createExtensionSource = (options) => {
   });
   delegatingSessions.add(pageController);
   messaging.start();
+  messaging.send({ type: "host_ready" });
   sendHostInfo();
   messaging.onDisconnect(() => {
     console.error("[ExtensionSource] Extension disconnected");
@@ -15030,13 +15127,26 @@ var createExtensionSource = (options) => {
   };
   const attachTarget = (targetId) => {
     const target = parseExtensionTargetId(targetId);
-    const session = requireOwnedSession(target.tabId);
+    const session = currentSession;
+    if (!session) {
+      if (target.frameId) {
+        throw new Error(`Cannot attach iframe ${target.frameId} before tab ${target.tabId} is attached`);
+      }
+      throw new Error(`Watcher ${hostInfo.watcherId} is a tab watcher. Use extension-control to attach tab ${target.tabId}.`);
+    }
+    if (session.tabId !== target.tabId) {
+      throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session.tabId}, not tab ${target.tabId}`);
+    }
     requestTargetSelection(session, target.frameId);
   };
   const detachTarget = (targetId) => {
     const target = parseExtensionTargetId(targetId);
-    const session = requireOwnedSession(target.tabId);
-    sessionManager.detachTab(session.tabId);
+    const session = currentSession;
+    if (!session || session.tabId === target.tabId) {
+      sessionManager.detachTab(target.tabId);
+      return;
+    }
+    throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session.tabId}, not tab ${target.tabId}`);
   };
   return {
     session: proxySession,
@@ -15080,9 +15190,6 @@ var createExtensionSource = (options) => {
     },
     stop,
     listTargets,
-    listTabs: async (filter) => {
-      return await sessionManager.listTabs(filter);
-    },
     attachTarget,
     detachTarget
   };
@@ -15095,16 +15202,6 @@ var createExtensionSource = (options) => {
       pid: hostInfo.watcherPid
     });
   }
-  function requireOwnedSession(tabId) {
-    const session = currentSession;
-    if (!session) {
-      throw createNotAttachedError();
-    }
-    if (session.tabId !== tabId) {
-      throw new Error(`Watcher ${hostInfo.watcherId} is pinned to tab ${session.tabId}, not tab ${tabId}`);
-    }
-    return session;
-  }
   function rebindDelegatingSessions() {
     for (const controller of delegatingSessions) {
       controller.rebind();
@@ -15207,13 +15304,15 @@ var createExtensionSource = (options) => {
     if (state2.activeAttachedAt == null) {
       state2.activeAttachedAt = Date.now();
     }
+    const targetReady = isTargetReady(session.tabId);
     emitStatus(target, null);
     messaging.send({
       type: "target_info",
       targetId: target.id,
       title: target.title,
       url: target.url,
-      attachedAt: state2.activeAttachedAt
+      attachedAt: state2.activeAttachedAt,
+      targetReady
     });
     events.onTargetChanged?.(session.handle, target);
   }
@@ -15354,7 +15453,7 @@ function delay4(ms) {
 
 // ../argus-watcher/dist/runtime/watcherServices.js
 var createWatcherRuntimeServices = (options, setup, callbacks) => {
-  const { sourceMode, chrome, artifactsBaseDir, netBuffer, realtimeNetBuffer, sessionHandle, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, watcherId, host, record } = setup;
+  const { sourceMode, chrome, artifactsBaseDir, netBuffer, realtimeNetBuffer, sessionHandle, ignoreMatcher, stripUrlPrefixes: stripUrlPrefixes2, watcherId, host, record, extensionRole } = setup;
   if (sourceMode === "extension") {
     const sourceHandle2 = createExtensionSource({
       events: {
@@ -15372,6 +15471,7 @@ var createWatcherRuntimeServices = (options, setup, callbacks) => {
       watcherId,
       watcherHost: host,
       watcherPort: record.port,
+      role: extensionRole,
       ignoreMatcher: ignoreMatcher ? (url) => ignoreMatcher.matches(url) : null,
       stripUrlPrefixes: stripUrlPrefixes2
     });
@@ -16085,7 +16185,7 @@ var runReload = defineWatcherCommand({
 import fs8 from "node:fs";
 import path10 from "node:path";
 var AUTO_CONFIG_CANDIDATES = [".argus/config.json", ".config/argus.json", "argus.config.json", "argus/config.json"];
-var EXPECTED_SHAPE_HINT = 'Expected shape: { chrome?: { start?: { url?: string, watcherId?: string, profile?: "temp"|"default-full"|"default-medium"|"default-lite", devTools?: boolean, headless?: boolean } }, watcher?: { start?: { id?: string, url?: string, chromeHost?: string, chromePort?: number, artifacts?: string, pageIndicator?: boolean, pageConsoleLogging?: "none"|"minimal"|"full", inject?: { file: string, exposeArgus?: boolean } } } }.';
+var EXPECTED_SHAPE_HINT = 'Expected shape: { plugins?: string[], pluginAliases?: Record<string, string>, chrome?: { start?: { url?: string, watcherId?: string, profile?: "temp"|"default-full"|"default-medium"|"default-lite", devTools?: boolean, headless?: boolean } }, watcher?: { start?: { id?: string, url?: string, chromeHost?: string, chromePort?: number, artifacts?: string, pageIndicator?: boolean, pageConsoleLogging?: "none"|"minimal"|"full", inject?: { file: string, exposeArgus?: boolean } } } }.';
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var invalidConfig = (configPath, message) => {
   console.error(`Invalid Argus config at ${configPath}: ${message} ${EXPECTED_SHAPE_HINT}`);
@@ -16159,6 +16259,25 @@ var validateOptionalStringArray = (value, label) => {
   }
   return { ok: true, value };
 };
+var validateOptionalStringMap = (value, label) => {
+  if (value === undefined) {
+    return { ok: true };
+  }
+  if (!isRecord(value)) {
+    return { ok: false, error: `${label} must be an object with string values.` };
+  }
+  const entries = [];
+  for (const [key, item] of Object.entries(value)) {
+    if (key.trim() === "") {
+      return { ok: false, error: `${label} keys must be non-empty strings.` };
+    }
+    if (typeof item !== "string" || item.trim() === "") {
+      return { ok: false, error: `${label}.${key} must be a non-empty string.` };
+    }
+    entries.push([key, item]);
+  }
+  return { ok: true, value: Object.fromEntries(entries) };
+};
 var validateOptionalSection = (value, label, validate) => {
   if (value === undefined) {
     return { ok: true };
@@ -16290,6 +16409,10 @@ var validateArgusConfig = (value) => {
   if (!pluginsResult.ok) {
     return pluginsResult;
   }
+  const pluginAliasesResult = validateOptionalStringMap(value.pluginAliases, '"pluginAliases"');
+  if (!pluginAliasesResult.ok) {
+    return pluginAliasesResult;
+  }
   const chromeResult = validateOptionalSection(value.chrome, '"chrome"', (section) => {
     if (section.start === undefined) {
       return { ok: true, value: {} };
@@ -16316,7 +16439,15 @@ var validateArgusConfig = (value) => {
   if (!watcherResult.ok) {
     return watcherResult;
   }
-  return { ok: true, value: { chrome: chromeResult.value, watcher: watcherResult.value, plugins: pluginsResult.value } };
+  return {
+    ok: true,
+    value: {
+      chrome: chromeResult.value,
+      watcher: watcherResult.value,
+      plugins: pluginsResult.value,
+      pluginAliases: pluginAliasesResult.value
+    }
+  };
 };
 var resolveArgusConfigPath = ({ cliPath, cwd }) => {
   if (cliPath) {
@@ -16767,25 +16898,13 @@ var runWatcherStart = async (options) => {
 var generateWatcherId = () => crypto2.randomBytes(3).toString("hex");
 
 // dist/commands/watcherStatus.js
-var runWatcherStatus = async (id, options) => {
-  const output = createOutput(options);
-  const result = await requestWatcherJson({
-    id,
-    path: "/status",
-    timeoutMs: 2000
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
+var runWatcherStatus = defineWatcherCommand({
+  build: () => ({ path: "/status", timeoutMs: 2000 }),
+  formatHuman: (status, { output, watcher }) => {
+    const readinessSuffix = status.targetReady === false ? " targetReady=false" : "";
+    output.writeHuman(`ok ${watcher.id} ${watcher.host}:${watcher.port} pid=${status.pid} attached=${status.attached}${readinessSuffix}`);
   }
-  const { watcher, data: status } = result;
-  const readinessSuffix = status.targetReady === false ? " targetReady=false" : "";
-  output.writeHuman(`ok ${watcher.id} ${watcher.host}:${watcher.port} pid=${status.pid} attached=${status.attached}${readinessSuffix}`);
-};
+});
 
 // dist/commands/watcherStop.js
 var runWatcherStop = async (id, _options) => {
@@ -16943,21 +17062,27 @@ var checkWatcherReachable = async (watcher) => {
 // dist/commands/watcherNativeHost.js
 var runWatcherNativeHost = async (options) => {
   const watcherId = options.id?.trim() || "extension";
+  const role = options.role?.trim() || "tab";
+  if (role !== "tab" && role !== "control") {
+    console.error(`Invalid native host role: ${role}. Expected "tab" or "control".`);
+    process.exit(2);
+  }
   let handle51;
   try {
     handle51 = await startWatcher({
       id: watcherId,
       source: "extension",
+      extensionRole: role,
       host: "127.0.0.1",
       port: 0,
       net: { enabled: true },
-      pageIndicator: { enabled: true }
+      pageIndicator: { enabled: role === "tab" }
     });
   } catch (error) {
     console.error(`Failed to start watcher: ${error instanceof Error ? error.message : error}`);
     process.exit(1);
   }
-  console.error(`[NativeHost] Watcher started: id=${handle51.watcher.id} port=${handle51.watcher.port}`);
+  console.error(`[NativeHost] Watcher started: id=${handle51.watcher.id} role=${role} port=${handle51.watcher.port}`);
   const cleanup = async () => {
     try {
       await handle51.close();
@@ -17080,7 +17205,7 @@ Examples:
 `).action(async (options) => {
     await runWatcherPrune(options);
   });
-  watcher.command("native-host").description("[internal] Start as Native Messaging host for Chrome extension").option("--id <watcherId>", "Watcher id (default: extension)").option("--json", "Output JSON for automation").action(async (options) => {
+  watcher.command("native-host").description("[internal] Start as Native Messaging host for Chrome extension").option("--id <watcherId>", "Watcher id (default: extension)").option("--role <role>", "Native host role: tab or control (default: tab)").option("--json", "Output JSON for automation").action(async (options) => {
     await runWatcherNativeHost(options);
   });
 }
@@ -17361,16 +17486,38 @@ var listPresetNames = () => {
 };
 
 // dist/commands/pageEmulation.js
-var runPageEmulationSet = async (id, options) => {
-  const output = createOutput(options);
+var runPageEmulationSet = defineWatcherCommand({
+  build: (_args, options, output) => buildPageEmulationSetPlan(options, output),
+  formatHuman: (res, { output, options }) => {
+    const state2 = buildEmulationState(options);
+    const label = formatViewportLabel(state2.viewport, state2.touch.enabled, state2.userAgent.value);
+    if (res.applied) {
+      output.writeHuman(`Applied emulation: ${label}`);
+    } else if (!res.attached) {
+      output.writeHuman(`Queued emulation (watcher detached): ${label}`);
+    } else {
+      output.writeHuman(`Emulation set but not applied: ${label}`);
+      if (res.error) {
+        output.writeWarn(`Error: ${res.error.message}`);
+      }
+    }
+  }
+});
+var buildPageEmulationSetPlan = (options, output) => {
+  const state2 = buildEmulationState(options, output);
+  if (!state2)
+    return null;
+  return { path: "/emulation", method: "POST", body: { action: "set", state: state2 }, timeoutMs: 1e4 };
+};
+var buildEmulationState = (options, output) => {
   let base = null;
   if (options.device) {
     const preset = resolvePreset(options.device);
     if (!preset) {
-      output.writeWarn(`Unknown device: ${options.device}`);
-      output.writeWarn(`Available: ${listPresetNames().join(", ")}`);
+      output?.writeWarn(`Unknown device: ${options.device}`);
+      output?.writeWarn(`Available: ${listPresetNames().join(", ")}`);
       process.exitCode = 2;
-      return;
+      return null;
     }
     base = { viewport: preset.viewport, touch: preset.touch, userAgent: preset.userAgent };
   }
@@ -17378,34 +17525,34 @@ var runPageEmulationSet = async (id, options) => {
   const heightRaw = options.height != null ? Number(options.height) : null;
   const dprRaw = options.dpr != null ? Number(options.dpr) : null;
   if (widthRaw != null && (!Number.isInteger(widthRaw) || widthRaw <= 0)) {
-    output.writeWarn("--width must be a positive integer");
+    output?.writeWarn("--width must be a positive integer");
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (heightRaw != null && (!Number.isInteger(heightRaw) || heightRaw <= 0)) {
-    output.writeWarn("--height must be a positive integer");
+    output?.writeWarn("--height must be a positive integer");
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (dprRaw != null && (!Number.isFinite(dprRaw) || dprRaw <= 0)) {
-    output.writeWarn("--dpr must be a positive number");
+    output?.writeWarn("--dpr must be a positive number");
     process.exitCode = 2;
-    return;
+    return null;
   }
   const hasWidth = widthRaw != null;
   const hasHeight = heightRaw != null;
   if ((hasWidth || hasHeight) && !base) {
     if (!hasWidth || !hasHeight) {
-      output.writeWarn("Both --width and --height are required when not using --device");
+      output?.writeWarn("Both --width and --height are required when not using --device");
       process.exitCode = 2;
-      return;
+      return null;
     }
   }
   if (!base && !hasWidth) {
-    output.writeWarn("Provide --device or --width + --height");
-    output.writeWarn(`Available devices: ${listPresetNames().join(", ")}`);
+    output?.writeWarn("Provide --device or --width + --height");
+    output?.writeWarn(`Available devices: ${listPresetNames().join(", ")}`);
     process.exitCode = 2;
-    return;
+    return null;
   }
   const baseViewport = base?.viewport ?? null;
   const width = widthRaw ?? baseViewport?.width ?? 0;
@@ -17415,137 +17562,48 @@ var runPageEmulationSet = async (id, options) => {
   const viewport = { width, height, deviceScaleFactor: dpr, mobile };
   const touchEnabled = options.touch ?? base?.touch ?? false;
   const uaValue = options.ua !== undefined ? options.ua : base?.userAgent ?? null;
-  const state2 = {
+  return {
     viewport,
     touch: { enabled: touchEnabled },
     userAgent: { value: uaValue }
   };
-  const result = await requestWatcherJson({
-    id,
-    path: "/emulation",
-    method: "POST",
-    body: { action: "set", state: state2 },
-    timeoutMs: 1e4,
-    returnErrorResponse: true
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  const response = result.data;
-  if (!response.ok) {
-    const err = response;
-    if (options.json) {
-      output.writeJson(response);
-    } else {
-      output.writeWarn(`Error: ${err.error.message}`);
-    }
-    process.exitCode = 1;
-    return;
-  }
-  if (options.json) {
-    output.writeJson(response);
-    return;
-  }
-  const res = response;
-  const label = formatViewportLabel(viewport, touchEnabled, uaValue);
-  if (res.applied) {
-    output.writeHuman(`Applied emulation: ${label}`);
-  } else if (!res.attached) {
-    output.writeHuman(`Queued emulation (watcher detached): ${label}`);
-  } else {
-    output.writeHuman(`Emulation set but not applied: ${label}`);
-    if (res.error) {
-      output.writeWarn(`Error: ${res.error.message}`);
-    }
-  }
 };
-var runPageEmulationClear = async (id, options) => {
-  const output = createOutput(options);
-  const result = await requestWatcherJson({
-    id,
-    path: "/emulation",
-    method: "POST",
-    body: { action: "clear" },
-    timeoutMs: 1e4,
-    returnErrorResponse: true
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
+var runPageEmulationClear = defineWatcherCommand({
+  build: () => ({ path: "/emulation", method: "POST", body: { action: "clear" }, timeoutMs: 1e4 }),
+  formatHuman: (_response, { output }) => {
+    output.writeHuman("Cleared emulation");
   }
-  const response = result.data;
-  if (!response.ok) {
-    const err = response;
-    if (options.json) {
-      output.writeJson(response);
+});
+var runPageEmulationStatus = defineWatcherCommand({
+  build: () => ({ path: "/emulation", method: "GET", timeoutMs: 5000 }),
+  formatHuman: (res, { output }) => {
+    const lines = [];
+    lines.push(`attached: ${res.attached}`);
+    lines.push(`applied:  ${res.applied}`);
+    if (res.state?.viewport) {
+      const vp = res.state.viewport;
+      lines.push(`viewport: ${vp.width}x${vp.height}@${vp.deviceScaleFactor} ${vp.mobile ? "mobile" : "desktop"}`);
     } else {
-      output.writeWarn(`Error: ${err.error.message}`);
+      lines.push("viewport: none");
     }
-    process.exitCode = 1;
-    return;
-  }
-  if (options.json) {
-    output.writeJson(response);
-    return;
-  }
-  output.writeHuman("Cleared emulation");
-};
-var runPageEmulationStatus = async (id, options) => {
-  const output = createOutput(options);
-  const result = await requestWatcherJson({
-    id,
-    path: "/emulation",
-    method: "GET",
-    timeoutMs: 5000,
-    returnErrorResponse: true
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  const response = result.data;
-  if (!response.ok) {
-    const err = response;
-    if (options.json) {
-      output.writeJson(response);
+    lines.push(`touch:    ${res.state?.touch?.enabled ? "enabled" : "disabled"}`);
+    if (res.state?.userAgent?.value) {
+      const ua = res.state.userAgent.value;
+      lines.push(`ua:       ${ua.length > 80 ? ua.slice(0, 77) + "..." : ua}`);
     } else {
-      output.writeWarn(`Error: ${err.error.message}`);
+      lines.push("ua:       default");
     }
-    process.exitCode = 1;
-    return;
-  }
-  if (options.json) {
-    output.writeJson(response);
-    return;
-  }
-  const res = response;
-  const lines = [];
-  lines.push(`attached: ${res.attached}`);
-  lines.push(`applied:  ${res.applied}`);
-  if (res.state?.viewport) {
-    const vp = res.state.viewport;
-    lines.push(`viewport: ${vp.width}x${vp.height}@${vp.deviceScaleFactor} ${vp.mobile ? "mobile" : "desktop"}`);
-  } else {
-    lines.push("viewport: none");
-  }
-  lines.push(`touch:    ${res.state?.touch?.enabled ? "enabled" : "disabled"}`);
-  if (res.state?.userAgent?.value) {
-    const ua = res.state.userAgent.value;
-    lines.push(`ua:       ${ua.length > 80 ? ua.slice(0, 77) + "..." : ua}`);
-  } else {
-    lines.push("ua:       default");
-  }
-  if (res.baseline.userAgent) {
-    const bua = res.baseline.userAgent;
-    lines.push(`baseline: ${bua.length > 80 ? bua.slice(0, 77) + "..." : bua}`);
-  }
-  if (res.lastError) {
-    lines.push(`error:    ${res.lastError.message}`);
-  }
-  output.writeHuman(lines.join(`
+    if (res.baseline.userAgent) {
+      const bua = res.baseline.userAgent;
+      lines.push(`baseline: ${bua.length > 80 ? bua.slice(0, 77) + "..." : bua}`);
+    }
+    if (res.lastError) {
+      lines.push(`error:    ${res.lastError.message}`);
+    }
+    output.writeHuman(lines.join(`
 `));
-};
+  }
+});
 var formatViewportLabel = (viewport, touch, ua) => {
   const parts = [`${viewport.width}x${viewport.height}@${viewport.deviceScaleFactor}`];
   if (viewport.mobile)
@@ -17915,46 +17973,38 @@ var appendRepeatedParams = (params, key, values) => {
 };
 
 // dist/commands/logs.js
-var runLogs = async (id, options) => {
-  const output = createOutput(options);
+var runLogs = defineWatcherCommand({
+  isJson: (options) => options.jsonFull === true,
+  build: (_args, options, output) => buildLogsPlan(options, output),
+  formatJson: (response, { options }) => options.jsonFull ? response.events : response.events.map((event) => previewLogEvent(event)),
+  formatHuman: (response, { output, watcher }) => {
+    for (const event of response.events) {
+      output.writeHuman(formatLogEvent(event, {
+        includeTimestamps: watcher.includeTimestamps
+      }));
+    }
+  }
+});
+var buildLogsPlan = (options, output) => {
   const params = new URLSearchParams;
   appendAfterLimitParams(params, options);
   const filters = appendLogFilterParams(params, options);
   if (filters.error) {
     output.writeWarn(filters.error);
     process.exitCode = 2;
-    return;
+    return null;
   }
   const since = appendSinceParam(params, options.since);
   if (since.error) {
     output.writeWarn(since.error);
     process.exitCode = 2;
-    return;
+    return null;
   }
-  const result = await requestWatcherJson({
-    id,
+  return {
     path: "/logs",
     query: params,
     timeoutMs: 5000
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  if (options.jsonFull) {
-    output.writeJson(result.data.events);
-    return;
-  }
-  if (options.json) {
-    const previewEvents = result.data.events.map((event) => previewLogEvent(event));
-    output.writeJson(previewEvents);
-    return;
-  }
-  for (const event of result.data.events) {
-    output.writeHuman(formatLogEvent(event, {
-      includeTimestamps: result.watcher.includeTimestamps
-    }));
-  }
+  };
 };
 
 // dist/commands/tail.js
@@ -18060,27 +18110,16 @@ Examples:
 }
 
 // dist/commands/netClear.js
-var runNetClear = async (id, options) => {
-  const output = createOutput(options);
-  const result = await requestWatcherAction({
-    id,
-    path: "/net/clear",
-    method: "POST",
-    timeoutMs: 5000
-  }, output);
-  if (!result) {
-    return;
+var runNetClear = defineWatcherCommand({
+  build: () => ({ path: "/net/clear", method: "POST", timeoutMs: 5000 }),
+  formatHuman: (response, { output, watcher }) => {
+    output.writeHuman(`cleared ${response.cleared} requests from ${watcher.id}`);
   }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
-  }
-  output.writeHuman(`cleared ${result.data.cleared} requests from ${result.watcher.id}`);
-};
+});
 
 // dist/commands/netExport.js
 import fs9 from "node:fs/promises";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // dist/eval/evalClient.js
 var evalOnce = async (input) => {
@@ -18256,10 +18295,147 @@ var resolveDerivedNetFilters = (options) => {
 
 // dist/commands/evalShared.js
 import { readFile as readFile2 } from "node:fs/promises";
+
+// dist/commands/evalBundle.js
+import { realpath } from "node:fs/promises";
+import path11 from "node:path";
+var esbuildModulePromise;
+var nodeModulesSegment = `${path11.sep}node_modules${path11.sep}`;
+var loadEsbuild = () => esbuildModulePromise ??= import("esbuild");
+var bundleEvalEntry = async (entryPath) => {
+  let entryPoint;
+  try {
+    entryPoint = await realpath(path11.resolve(entryPath));
+  } catch {
+    return { ok: false, error: `Failed to read entry file: ${entryPath}` };
+  }
+  const bundleRoot = path11.dirname(entryPoint);
+  try {
+    const esbuild = await loadEsbuild();
+    const result = await esbuild.build({
+      absWorkingDir: bundleRoot,
+      entryPoints: [entryPoint],
+      bundle: true,
+      write: false,
+      splitting: false,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      sourcemap: false,
+      logLevel: "silent",
+      plugins: [createLocalFilesPlugin(bundleRoot)]
+    });
+    const output = result.outputFiles[0];
+    if (output == null) {
+      return { ok: false, error: "Bundle produced no output." };
+    }
+    const code = `${output.text.trimEnd()}
+//# sourceURL=argus-file://${entryPoint}
+`;
+    return { ok: true, code };
+  } catch (error) {
+    return { ok: false, error: formatBundleFailure(error) };
+  }
+};
+var createLocalFilesPlugin = (bundleRoot) => {
+  const bundleRootPrefix = bundleRoot.endsWith(path11.sep) ? bundleRoot : `${bundleRoot}${path11.sep}`;
+  return {
+    name: "argus-eval-bundle",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point") {
+          return;
+        }
+        if (args.path.startsWith("node:")) {
+          return bundleError(`Node built-in import ${JSON.stringify(args.path)} is not allowed in page eval.`);
+        }
+        if (!args.path.startsWith(".") && !path11.isAbsolute(args.path)) {
+          return bundleError(`Import ${JSON.stringify(args.path)} is not allowed. Use relative local files under ${bundleRoot}.`);
+        }
+        return;
+      });
+      build.onLoad({ filter: /.*/ }, async (args) => {
+        let resolvedPath;
+        try {
+          resolvedPath = await realpath(args.path);
+        } catch {
+          return bundleError(`Failed to read file: ${args.path}`);
+        }
+        if (resolvedPath !== bundleRoot && !resolvedPath.startsWith(bundleRootPrefix)) {
+          return bundleError(`Import escapes the entry directory: ${args.path}`);
+        }
+        if (resolvedPath.includes(nodeModulesSegment)) {
+          return bundleError(`Import from node_modules is not allowed: ${args.path}`);
+        }
+        return;
+      });
+      build.onEnd((result) => {
+        if (result.errors.length > 0) {
+          return;
+        }
+        const outputs = result.outputFiles ?? [];
+        if (outputs.length !== 1) {
+          return bundleError(`Bundle produced ${outputs.length} outputs; expected exactly one script.`);
+        }
+        if (/\bexport\b/.test(outputs[0]?.text ?? "")) {
+          return bundleError("Bundled script contains top-level export statements, which page eval cannot run. Remove exports from the entry file (helpers may still export symbols for import).");
+        }
+      });
+    }
+  };
+};
+var bundleError = (text) => ({ errors: [{ text }] });
+var formatBundleFailure = (error) => {
+  if (isEsbuildFailure(error)) {
+    return error.errors.map(formatEsbuildMessage).join(`
+`);
+  }
+  return error instanceof Error ? error.message : String(error);
+};
+var isEsbuildFailure = (error) => error instanceof Error && ("errors" in error) && Array.isArray(error.errors) && error.errors.length > 0;
+var formatEsbuildMessage = (issue) => {
+  const message = issue.text || "Bundle failed.";
+  const { file, line, column } = issue.location ?? {};
+  if (!file) {
+    return message;
+  }
+  if (line == null || column == null) {
+    return `${file}: ${message}`;
+  }
+  return `${file}:${line}:${column}: ${message}`;
+};
+
+// dist/commands/evalShared.js
+var prepareEvalExpression = async (inline, options, output) => {
+  const evalArgs = parseEvalArgs(options.arg);
+  if (evalArgs.error) {
+    output.writeWarn(evalArgs.error);
+    return null;
+  }
+  const resolvedExpression = await resolveExpression(inline, options, output);
+  if (resolvedExpression == null) {
+    return null;
+  }
+  const args = evalArgs.value;
+  if (!options.iframe) {
+    return {
+      expression: resolvedExpression,
+      args: hasEvalArgs2(args) ? args : undefined
+    };
+  }
+  return {
+    expression: wrapForIframeEval(wrapExpressionWithArgs(resolvedExpression, args), {
+      selector: options.iframe,
+      namespace: options.iframeNamespace ?? "argus",
+      timeoutMs: parseNumber(options.iframeTimeout) ?? 5000
+    })
+  };
+};
 var resolveExpression = async (inline, options, output) => {
   const wantsStdin = options.stdin === true || inline === "-";
   const hasInline = inline != null && inline !== "-";
-  const hasFile = options.file != null;
+  const filePath = options.file;
+  const hasFile = filePath != null;
   if (hasInline && hasFile) {
     output.writeWarn("Cannot combine an inline expression with --file");
     return null;
@@ -18272,41 +18448,74 @@ var resolveExpression = async (inline, options, output) => {
     output.writeWarn("Cannot combine --file with stdin input");
     return null;
   }
-  if (hasFile) {
+  if (options.bundle && !hasFile) {
+    output.writeWarn("--bundle requires --file");
+    return null;
+  }
+  let expression;
+  if (hasFile && options.bundle) {
+    const bundled = await bundleEvalEntry(filePath);
+    if (!bundled.ok) {
+      output.writeWarn(`Failed to bundle --file: ${bundled.error}`);
+      return null;
+    }
+    if (!bundled.code.trim()) {
+      output.writeWarn(`Bundled file is empty: ${options.file}`);
+      return null;
+    }
+    expression = bundled.code;
+  } else if (hasFile) {
     try {
-      const content = await readFile2(options.file ?? "", "utf8");
+      const content = await readFile2(filePath, "utf8");
       if (!content.trim()) {
         output.writeWarn(`File is empty: ${options.file}`);
         return null;
       }
-      return content;
+      expression = content;
     } catch (error) {
       output.writeWarn(`Failed to read --file: ${formatError(error)}`);
       return null;
     }
-  }
-  if (wantsStdin) {
+  } else if (wantsStdin) {
     try {
       const content = await readStdin();
       if (!content.trim()) {
         output.writeWarn("Stdin input is empty");
         return null;
       }
-      return content;
+      expression = content;
     } catch (error) {
       output.writeWarn(`Failed to read stdin: ${formatError(error)}`);
       return null;
     }
-  }
-  if (hasInline) {
+  } else if (hasInline) {
     if (!inline.trim()) {
       output.writeWarn("Expression is empty");
       return null;
     }
-    return inline;
+    expression = inline;
+  } else {
+    output.writeWarn("Expression is required. Provide an inline expression, --file, or --stdin (or pass - as expression).");
+    return null;
+  }
+  return await prependInjectSource(expression, options.inject, output);
+};
+var prependInjectSource = async (expression, injectPath, output) => {
+  if (injectPath == null) {
+    return expression;
+  }
+  try {
+    const injectSource = await readFile2(injectPath, "utf8");
+    if (!injectSource.trim()) {
+      output.writeWarn(`Inject file is empty: ${injectPath}`);
+      return null;
+    }
+    return `${injectSource}
+${expression}`;
+  } catch (error) {
+    output.writeWarn(`Failed to read --inject: ${formatError(error)}`);
+    return null;
   }
-  output.writeWarn("Expression is required. Provide an inline expression, --file, or --stdin (or pass - as expression).");
-  return null;
 };
 var readStdin = async () => new Promise((resolve2, reject) => {
   let data = "";
@@ -18822,7 +19031,7 @@ var validateNetExportOptions = (options) => {
   return { value: { out, format: "har" } };
 };
 var writeHarFile = async (outPath, har) => {
-  await fs9.mkdir(path11.dirname(outPath), { recursive: true });
+  await fs9.mkdir(path12.dirname(outPath), { recursive: true });
   await fs9.writeFile(outPath, `${JSON.stringify(har, null, 2)}
 `, "utf8");
 };
@@ -19169,10 +19378,10 @@ var fetchNetRequestBody = async (watcher, query, part, output, config = {}) => {
   bodyQuery.set("part", part);
   return await fetchNetRequestRoute(watcher, "/net/request/body", bodyQuery, NET_REQUEST_BODY_TIMEOUT_MS, output, config);
 };
-var fetchNetRequestRoute = async (watcher, path12, query, timeoutMs, output, config = {}) => {
+var fetchNetRequestRoute = async (watcher, path13, query, timeoutMs, output, config = {}) => {
   try {
     const response = await fetchWatcherJson(watcher, {
-      path: path12,
+      path: path13,
       query,
       timeoutMs,
       returnErrorResponse: true
@@ -19380,32 +19589,28 @@ var writeInspectNoMatch = (output, pattern, settleMs, timedOut) => {
 };
 
 // dist/commands/net.js
-var runNet = async (id, options) => {
-  const output = createOutput(options);
+var runNet = defineWatcherCommand({
+  build: (_args, options, output) => buildNetPlan(options, output),
+  formatJson: (response) => response.requests,
+  formatHuman: (response, { output }) => {
+    for (const request of response.requests) {
+      output.writeHuman(formatNetworkRequest(request));
+    }
+  }
+});
+var buildNetPlan = (options, output) => {
   const params = new URLSearchParams;
   const query = appendNetCommandParams(params, options);
   if (query.error) {
     output.writeWarn(query.error);
     process.exitCode = 2;
-    return;
+    return null;
   }
-  const result = await requestWatcherJson({
-    id,
+  return {
     path: "/net",
     query: params,
     timeoutMs: 5000
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data.requests);
-    return;
-  }
-  for (const request of result.data.requests) {
-    output.writeHuman(formatNetworkRequest(request));
-  }
+  };
 };
 
 // dist/commands/netRequestTarget.js
@@ -19717,7 +19922,7 @@ var runNetSse = async (id, options) => {
     process.exitCode = 2;
     return;
   }
-  const result = await requestWatcherAction({ id, path: "/net/sse", query: params, timeoutMs: 5000 }, output);
+  const result = await requestWatcherCommandAction({ id, path: "/net/sse", query: params, timeoutMs: 5000 }, output);
   if (!result) {
     return;
   }
@@ -19836,7 +20041,7 @@ var runNetWebSocket = async (id, options) => {
     process.exitCode = 2;
     return;
   }
-  const result = await requestWatcherAction({ id, path: "/net/ws", query: params, timeoutMs: 5000 }, output);
+  const result = await requestWatcherCommandAction({ id, path: "/net/ws", query: params, timeoutMs: 5000 }, output);
   if (!result) {
     return;
   }
@@ -19854,7 +20059,7 @@ var runNetWebSocketShow = async (id, connection, options) => {
   if (!query) {
     return;
   }
-  const result = await requestWatcherAction({ id, path: "/net/ws/connection", query, timeoutMs: 5000 }, output);
+  const result = await requestWatcherCommandAction({ id, path: "/net/ws/connection", query, timeoutMs: 5000 }, output);
   if (!result) {
     return;
   }
@@ -20142,35 +20347,33 @@ var toCamelCase = (flag) => flag.replace(/^--/, "").replace(/-([a-z])/g, (_match
 import { writeFile as writeFile2 } from "node:fs/promises";
 var COOKIE_EXPORT_FORMATS = new Set(["netscape", "json", "header"]);
 var fetchAuthCookies = async (id, input, output) => {
-  const result = await requestWatcherJson({
+  const result = await requestWatcherCommandJson({
     id,
     path: "/auth/cookies",
     query: buildCookieQuery(input),
     timeoutMs: 1e4
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
+  }, output);
+  if (!result)
     return null;
-  }
   return result.data;
 };
 var normalizeCookieIdentityInput = (input, output) => {
   const name = input.name.trim();
   const domain = input.domain.trim();
-  const path12 = input.path.trim();
+  const path13 = input.path.trim();
   if (!name) {
     return writeCookieInputError(output, "name is required");
   }
   if (!domain) {
     return writeCookieInputError(output, "domain is required");
   }
-  if (!path12) {
+  if (!path13) {
     return writeCookieInputError(output, "path is required");
   }
-  if (!path12.startsWith("/")) {
+  if (!path13.startsWith("/")) {
     return writeCookieInputError(output, 'path must start with "/"');
   }
-  return { name, domain, path: path12 };
+  return { name, domain, path: path13 };
 };
 var parseCookieSetInput = (input, output) => {
   const identity = normalizeCookieIdentityInput(input, output);
@@ -20380,116 +20583,104 @@ var runAuthExportCookies = async (id, options) => {
   const serialized = serializeCookies(filterCookies(response.origin, response.cookies, options), format);
   await writeOutput2(serialized, options.out);
 };
-var runAuthCookieGet = async (id, name, options) => {
-  const output = createOutput(options);
-  const identity = normalizeCookieIdentityInput({ name, domain: options.domain, path: options.path }, output);
-  if (!identity) {
-    return;
-  }
-  const result = await requestWatcherAction({
-    id,
-    path: "/auth/cookies/get",
-    method: "POST",
-    body: {
-      ...identity,
-      includeValue: options.showValue === true
+var runAuthCookieGet = defineWatcherCommand({
+  build: ([name], options, output) => {
+    const identity = normalizeCookieIdentityInput({ name, domain: options.domain, path: options.path }, output);
+    if (!identity) {
+      return null;
     }
-  }, output);
-  if (!result) {
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
-  }
-  if (!result.data.cookie) {
-    output.writeHuman("No cookie matched exact identity.");
-    return;
-  }
-  output.writeHuman(formatCookieLine(result.data.cookie, options.showValue === true));
-};
-var runAuthCookieSet = async (id, name, value, options) => {
-  const output = createOutput(options);
-  const cookie = parseCookieSetInput({ name, value, ...options }, output);
-  if (!cookie) {
-    return;
-  }
-  const result = await requestWatcherAction({
-    id,
-    path: "/auth/cookies/set",
-    method: "POST",
-    body: { cookie }
-  }, output);
-  if (!result) {
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
-  }
-  output.writeHuman(`Set ${formatCookieLine(result.data.cookie, false)}`);
-};
-var runAuthCookieDelete = async (id, name, options) => {
-  const output = createOutput(options);
-  const identity = normalizeCookieIdentityInput({ name, domain: options.domain, path: options.path }, output);
-  if (!identity) {
-    return;
-  }
-  const result = await requestWatcherAction({
-    id,
-    path: "/auth/cookies/delete",
-    method: "POST",
-    body: identity
-  }, output);
-  if (!result) {
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
-  }
-  if (!result.data.deleted) {
-    output.writeHuman("No cookie matched exact identity.");
-    return;
-  }
-  output.writeHuman(`Deleted ${formatCookieIdentityLine(result.data.cookie)}`);
-};
-var runAuthCookieClear = async (id, options) => {
-  const output = createOutput(options);
-  const scope = resolveCookieClearScope(options, output);
-  if (!scope) {
-    return;
+    return {
+      path: "/auth/cookies/get",
+      method: "POST",
+      body: {
+        ...identity,
+        includeValue: options.showValue === true
+      }
+    };
+  },
+  formatHuman: (response, { output, options }) => {
+    if (!response.cookie) {
+      output.writeHuman("No cookie matched exact identity.");
+      return;
+    }
+    output.writeHuman(formatCookieLine(response.cookie, options.showValue === true));
   }
-  const result = await requestWatcherAction({
-    id,
-    path: "/auth/cookies/clear",
-    method: "POST",
-    body: {
-      scope,
-      domain: scope === "domain" ? options.domain : undefined,
-      sessionOnly: options.sessionOnly === true,
-      authOnly: options.authOnly === true
+});
+var runAuthCookieSet = defineWatcherCommand({
+  build: ([name, value], options, output) => {
+    const cookie = parseCookieSetInput({ name, value, ...options }, output);
+    if (!cookie) {
+      return null;
     }
-  }, output);
-  if (!result) {
-    return;
+    return {
+      path: "/auth/cookies/set",
+      method: "POST",
+      body: { cookie }
+    };
+  },
+  formatHuman: (response, { output }) => {
+    output.writeHuman(`Set ${formatCookieLine(response.cookie, false)}`);
   }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
+});
+var runAuthCookieDelete = defineWatcherCommand({
+  build: ([name], options, output) => {
+    const identity = normalizeCookieIdentityInput({ name, domain: options.domain, path: options.path }, output);
+    if (!identity) {
+      return null;
+    }
+    return {
+      path: "/auth/cookies/delete",
+      method: "POST",
+      body: identity
+    };
+  },
+  formatHuman: (response, { output }) => {
+    if (!response.deleted) {
+      output.writeHuman("No cookie matched exact identity.");
+      return;
+    }
+    output.writeHuman(`Deleted ${formatCookieIdentityLine(response.cookie)}`);
   }
-  const scopeSuffix = result.data.scopeValue ? ` (${result.data.scopeValue})` : "";
-  output.writeHuman(`Cleared ${result.data.cleared} cookie(s) from ${result.data.scope}${scopeSuffix}`);
-  for (const cookie of result.data.cookies) {
-    output.writeHuman(formatCookieIdentityLine(cookie));
+});
+var runAuthCookieClear = defineWatcherCommand({
+  build: (_args, options, output) => {
+    const scope = resolveCookieClearScope(options, output);
+    if (!scope) {
+      return null;
+    }
+    return {
+      path: "/auth/cookies/clear",
+      method: "POST",
+      body: {
+        scope,
+        domain: scope === "domain" ? options.domain : undefined,
+        sessionOnly: options.sessionOnly === true,
+        authOnly: options.authOnly === true
+      }
+    };
+  },
+  formatHuman: (response, { output }) => {
+    const scopeSuffix = response.scopeValue ? ` (${response.scopeValue})` : "";
+    output.writeHuman(`Cleared ${response.cleared} cookie(s) from ${response.scope}${scopeSuffix}`);
+    for (const cookie of response.cookies) {
+      output.writeHuman(formatCookieIdentityLine(cookie));
+    }
   }
-};
+});
 
 // dist/cli/register/registerAuth.js
 function registerAuth(program2) {
   const auth = program2.command("auth").description("Inspect, export, and load browser auth state");
-  const cookies2 = auth.command("cookies").description("Inspect and mutate browser cookies");
-  addCookieScopeOptions(cookies2.command("list").alias("ls"), "Only include first-party cookies for the attached page origin").argument("[id]", "Watcher id").description("List cookies for the attached page").option("--domain <domain>", "Filter cookies by domain suffix").option("--session-only", "Show only session cookies").option("--http-only", "Show only HttpOnly cookies").option("--secure", "Show only Secure cookies").option("--show-values", "Reveal raw cookie values instead of previews").option("--json", "Output JSON for automation").addHelpText("after", `
+  const cookies2 = addCookieListOptions(auth.command("cookies").argument("[id]", "Watcher id").description("Inspect and mutate browser cookies"), "Only include first-party cookies for the attached page origin").addHelpText("after", `
+Examples:
+  $ argus auth cookies app
+  $ argus auth cookies app --for-origin --exclude-tracking
+  $ argus auth cookies app --domain example.com
+  $ argus auth cookies app --session-only --show-values
+`).action(async (id, options) => {
+    await runAuthCookies(id, options);
+  });
+  addCookieListOptions(cookies2.command("list").alias("ls"), "Only include first-party cookies for the attached page origin").argument("[id]", "Watcher id").description("List cookies for the attached page").addHelpText("after", `
 Examples:
   $ argus auth cookies list app
   $ argus auth cookies ls app --for-origin --exclude-tracking
@@ -20571,27 +20762,71 @@ Examples:
   });
 }
 var addCookieScopeOptions = (command, forOriginDescription) => command.option("--for-origin", forOriginDescription).option("--exclude-tracking", "Hide common analytics/tracking cookies such as _ga and _ym");
+var addCookieListOptions = (command, forOriginDescription) => addCookieScopeOptions(command, forOriginDescription).option("--domain <domain>", "Filter cookies by domain suffix").option("--session-only", "Show only session cookies").option("--http-only", "Show only HttpOnly cookies").option("--secure", "Show only Secure cookies").option("--show-values", "Reveal raw cookie values instead of previews").option("--json", "Output JSON for automation");
+
+// dist/commands/evalPolling.js
+var pollEval = async (input) => {
+  let running = true;
+  const stop = () => {
+    running = false;
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  try {
+    const startTime = Date.now();
+    let iteration = 0;
+    while (running) {
+      if (input.totalTimeoutMs != null) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= input.totalTimeoutMs) {
+          return { kind: "timeout", elapsedMs: elapsed };
+        }
+      }
+      iteration += 1;
+      const result = await evalWithRetries({
+        watcher: input.watcher,
+        expression: input.expression,
+        args: input.args,
+        awaitPromise: input.awaitPromise,
+        returnByValue: input.returnByValue,
+        timeoutMs: input.timeoutMs,
+        failOnException: input.failOnException,
+        retryCount: input.retryCount
+      });
+      if (!result.ok) {
+        return { kind: "eval-error", failure: result };
+      }
+      const context = { response: result.response, iteration, attempt: result.attempt };
+      input.onResult?.(result.response, context);
+      const stopResult = input.shouldStop?.(context);
+      if (stopResult) {
+        if (!stopResult.ok) {
+          return { kind: "condition-error", error: stopResult.error };
+        }
+        if (stopResult.matched) {
+          return { kind: "matched", response: result.response, iteration, attempt: result.attempt };
+        }
+      }
+      if (input.count != null && iteration >= input.count) {
+        return { kind: "exhausted", iterations: iteration };
+      }
+      await sleep3(input.intervalMs);
+    }
+    return { kind: "interrupted" };
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  }
+};
 
 // dist/commands/eval.js
 var runEval = async (id, rawExpression, options) => {
   const output = createOutput(options);
-  const evalArgs = parseEvalArgs(options.arg);
-  if (evalArgs.error) {
-    output.writeWarn(evalArgs.error);
-    process.exitCode = 2;
-    return;
-  }
-  const resolvedExpression = await resolveExpression(rawExpression, options, output);
-  if (resolvedExpression == null) {
+  const prepared = await prepareEvalExpression(rawExpression, options, output);
+  if (prepared == null) {
     process.exitCode = 2;
     return;
   }
-  const requestArgs = !options.iframe && hasEvalArgs2(evalArgs.value) ? evalArgs.value : undefined;
-  const expression = options.iframe ? wrapForIframeEval(wrapExpressionWithArgs(resolvedExpression, evalArgs.value), {
-    selector: options.iframe,
-    namespace: options.iframeNamespace ?? "argus",
-    timeoutMs: parseNumber(options.iframeTimeout) ?? 5000
-  }) : resolvedExpression;
   const retryCount = parseRetryCount(options.retry);
   if (retryCount.error) {
     output.writeWarn(retryCount.error);
@@ -20634,8 +20869,8 @@ var runEval = async (id, rawExpression, options) => {
   if (intervalMs.value == null) {
     const singleResult = await evalWithRetries({
       watcher,
-      expression,
-      args: requestArgs,
+      expression: prepared.expression,
+      args: prepared.args,
       awaitPromise: options.await ?? true,
       returnByValue: options.returnByValue ?? true,
       timeoutMs,
@@ -20650,51 +20885,45 @@ var runEval = async (id, rawExpression, options) => {
     printSuccess(singleResult.response, options, output, false);
     return;
   }
-  let running = true;
-  const stop = () => {
-    running = false;
-  };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-  let iteration = 0;
-  while (running) {
-    iteration += 1;
-    const iterationResult = await evalWithRetries({
-      watcher,
-      expression,
-      args: requestArgs,
-      awaitPromise: options.await ?? true,
-      returnByValue: options.returnByValue ?? true,
-      timeoutMs,
-      failOnException: options.failOnException ?? true,
-      retryCount: retryCount.value
-    });
-    if (!iterationResult.ok) {
-      printError(iterationResult, options, output);
-      process.exitCode = 1;
-      return;
-    }
-    printSuccess(iterationResult.response, options, output, true);
-    if (untilEvaluator.evaluator) {
+  const pollResult = await pollEval({
+    watcher,
+    expression: prepared.expression,
+    args: prepared.args,
+    awaitPromise: options.await ?? true,
+    returnByValue: options.returnByValue ?? true,
+    timeoutMs,
+    failOnException: options.failOnException ?? true,
+    retryCount: retryCount.value,
+    intervalMs: intervalMs.value,
+    count: countValue.value,
+    onResult: (response) => {
+      printSuccess(response, options, output, true);
+    },
+    shouldStop: (context) => {
+      if (!untilEvaluator.evaluator) {
+        return { ok: true, matched: false };
+      }
       const untilResult = untilEvaluator.evaluator({
-        result: iterationResult.response.result,
-        exception: iterationResult.response.exception ?? null,
-        iteration,
-        attempt: iterationResult.attempt
+        result: context.response.result,
+        exception: context.response.exception ?? null,
+        iteration: context.iteration,
+        attempt: context.attempt
       });
-      if (!untilResult.ok) {
-        printError({ kind: "until", error: untilResult.error }, options, output);
-        process.exitCode = 1;
-        return;
-      }
-      if (untilResult.matched) {
-        return;
-      }
-    }
-    if (countValue.value != null && iteration >= countValue.value) {
-      return;
+      return untilResult.ok ? { ok: true, matched: untilResult.matched } : { ok: false, error: untilResult.error };
     }
-    await sleep3(intervalMs.value);
+  });
+  if (pollResult.kind === "eval-error") {
+    printError(pollResult.failure, options, output);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "condition-error") {
+    printError({ kind: "until", error: pollResult.error }, options, output);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "interrupted") {
+    process.exitCode = 130;
   }
 };
 var compileUntil = (condition) => {
@@ -20725,23 +20954,11 @@ var compileUntil = (condition) => {
 // dist/commands/evalUntil.js
 var runEvalUntil = async (id, rawExpression, options) => {
   const output = createOutput(options);
-  const evalArgs = parseEvalArgs(options.arg);
-  if (evalArgs.error) {
-    output.writeWarn(evalArgs.error);
+  const prepared = await prepareEvalExpression(rawExpression, options, output);
+  if (prepared == null) {
     process.exitCode = 2;
     return;
   }
-  const resolvedExpression = await resolveExpression(rawExpression, options, output);
-  if (resolvedExpression == null) {
-    process.exitCode = 2;
-    return;
-  }
-  const requestArgs = !options.iframe && hasEvalArgs2(evalArgs.value) ? evalArgs.value : undefined;
-  const expression = options.iframe ? wrapForIframeEval(wrapExpressionWithArgs(resolvedExpression, evalArgs.value), {
-    selector: options.iframe,
-    namespace: options.iframeNamespace ?? "argus",
-    timeoutMs: parseNumber(options.iframeTimeout) ?? 5000
-  }) : resolvedExpression;
   const retryCount = parseRetryCount(options.retry);
   if (retryCount.error) {
     output.writeWarn(retryCount.error);
@@ -20772,57 +20989,50 @@ var runEvalUntil = async (id, rawExpression, options) => {
     return;
   const { watcher } = resolved;
   const timeoutMs = parseNumber(options.timeout);
-  let running = true;
-  let interrupted = false;
-  const stop = () => {
-    running = false;
-    interrupted = true;
-  };
-  process.on("SIGINT", stop);
-  process.on("SIGTERM", stop);
-  const startTime = Date.now();
-  let iteration = 0;
-  while (running) {
-    if (totalTimeoutMs.value != null) {
-      const elapsed = Date.now() - startTime;
-      if (elapsed >= totalTimeoutMs.value) {
-        output.writeWarn(`Total timeout exceeded (${options.totalTimeout})`);
-        process.exitCode = 1;
-        return;
+  const pollResult = await pollEval({
+    watcher,
+    expression: prepared.expression,
+    args: prepared.args,
+    awaitPromise: options.await ?? true,
+    returnByValue: options.returnByValue ?? true,
+    timeoutMs,
+    failOnException: options.failOnException ?? true,
+    retryCount: retryCount.value,
+    intervalMs: pollIntervalMs,
+    count: countValue.value,
+    totalTimeoutMs: totalTimeoutMs.value,
+    onResult: (response) => {
+      if (!response.result && options.verbose) {
+        printSuccess(response, options, output, true);
       }
-    }
-    iteration += 1;
-    const iterationResult = await evalWithRetries({
-      watcher,
-      expression,
-      args: requestArgs,
-      awaitPromise: options.await ?? true,
-      returnByValue: options.returnByValue ?? true,
-      timeoutMs,
-      failOnException: options.failOnException ?? true,
-      retryCount: retryCount.value
-    });
-    if (!iterationResult.ok) {
-      printError(iterationResult, options, output);
-      process.exitCode = 1;
-      return;
-    }
-    const isTruthy = Boolean(iterationResult.response.result);
-    if (isTruthy) {
-      printSuccess(iterationResult.response, options, output, false);
-      return;
-    }
-    if (options.verbose) {
-      printSuccess(iterationResult.response, options, output, true);
-    }
-    if (countValue.value != null && iteration >= countValue.value) {
-      output.writeWarn(`Exhausted after ${iteration} iterations without a truthy result`);
-      process.exitCode = 1;
-      return;
-    }
-    await sleep3(pollIntervalMs);
+    },
+    shouldStop: ({ response }) => ({ ok: true, matched: Boolean(response.result) })
+  });
+  if (pollResult.kind === "matched") {
+    printSuccess(pollResult.response, options, output, false);
+    return;
+  }
+  if (pollResult.kind === "eval-error") {
+    printError(pollResult.failure, options, output);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "timeout") {
+    output.writeWarn(`Total timeout exceeded (${options.totalTimeout})`);
+    process.exitCode = 1;
+    return;
   }
-  if (interrupted) {
+  if (pollResult.kind === "exhausted") {
+    output.writeWarn(`Exhausted after ${pollResult.iterations} iterations without a truthy result`);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "condition-error") {
+    output.writeWarn(pollResult.error);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "interrupted") {
     process.exitCode = 130;
   }
 };
@@ -20911,11 +21121,13 @@ ${script}})();
 // dist/cli/register/registerEval.js
 var collectValue = (value, previous = []) => [...previous, value];
 function registerEval(program2) {
-  const evalCmd = program2.command("eval").alias("js").argument("[id]", "Watcher id to query").argument("[expression]", "JS expression to evaluate (or use --file / --stdin)").description("Evaluate a JS expression in the connected page").option("--no-await", "Do not await promises").option("--timeout <ms>", "Eval timeout in milliseconds").option("--json", "Output JSON for automation").option("--no-return-by-value", "Disable returnByValue (use preview)").option("--no-fail-on-exception", "Do not exit with code 1 when the evaluation throws").option("--retry <n>", "Retry failed evaluations up to N times").option("-q, --silent", "Suppress success output; only emit output on error").option("--interval <ms|duration>", "Re-evaluate every interval (e.g. 500, 3s)").option("--count <n>", "Stop after N iterations (requires --interval)").option("--until <condition>", "Stop when local condition becomes truthy (requires --interval)").option("-f, --file <path>", "Read expression from a file").option("--stdin", "Read expression from stdin").option("--iframe <selector>", "Eval in iframe via postMessage (requires helper script)").option("--iframe-namespace <name>", "Message type prefix for iframe eval (default: argus)").option("--iframe-timeout <ms>", "Timeout for iframe postMessage response (default: 5000)").option("--arg <key=value>", "Argument exposed to eval scripts as args[key]", collectValue, []).addHelpText("after", `
+  const evalCmd = program2.command("eval").alias("js").argument("[id]", "Watcher id to query").argument("[expression]", "JS expression to evaluate (or use --file / --stdin)").description("Evaluate a JS expression in the connected page").option("--no-await", "Do not await promises").option("--timeout <ms>", "Eval timeout in milliseconds").option("--json", "Output JSON for automation").option("--no-return-by-value", "Disable returnByValue (use preview)").option("--no-fail-on-exception", "Do not exit with code 1 when the evaluation throws").option("--retry <n>", "Retry failed evaluations up to N times").option("-q, --silent", "Suppress success output; only emit output on error").option("--interval <ms|duration>", "Re-evaluate every interval (e.g. 500, 3s)").option("--count <n>", "Stop after N iterations (requires --interval)").option("--until <condition>", "Stop when local condition becomes truthy (requires --interval)").option("-f, --file <path>", "Read expression from a file").option("--bundle", "Bundle local imports from --file into one script before eval").option("--stdin", "Read expression from stdin").option("--inject <path>", "Read setup code from a file and run it before the expression").option("--iframe <selector>", "Eval in iframe via postMessage (requires helper script)").option("--iframe-namespace <name>", "Message type prefix for iframe eval (default: argus)").option("--iframe-timeout <ms>", "Timeout for iframe postMessage response (default: 5000)").option("--arg <key=value>", "Argument exposed to eval scripts as args[key]", collectValue, []).addHelpText("after", `
 Examples:
   $ argus eval app "location.href"
   $ argus eval app "await fetch('/ping').then(r => r.status)"
   $ argus eval app --file ./script.js
+  $ argus eval app --file ./script.js --bundle
+  $ argus eval app "window.store.getState()" --inject ./debug-hooks.js
   $ argus eval app --file ./script.js --arg level=10 --arg mode=fast
   $ cat script.js | argus eval app --stdin
   $ argus eval app - < script.js
@@ -20939,7 +21151,9 @@ Examples:
       count: options.count,
       until: options.until,
       file: options.file,
+      bundle: options.bundle,
       stdin: options.stdin,
+      inject: options.inject,
       iframe: options.iframe,
       iframeNamespace: options.iframeNamespace,
       iframeTimeout: options.iframeTimeout,
@@ -20955,7 +21169,7 @@ Examples:
 `).action(async (options) => {
     await runIframeHelper(options);
   });
-  program2.command("eval-until").alias("wait").argument("[id]", "Watcher id to query").argument("[expression]", "JS expression to poll until truthy (or use --file / --stdin)").description("Poll a JS expression until it returns a truthy value").option("--no-await", "Do not await promises").option("--timeout <ms>", "Per-eval timeout in milliseconds").option("--json", "Output JSON for automation").option("--no-return-by-value", "Disable returnByValue (use preview)").option("--no-fail-on-exception", "Do not exit with code 1 when the evaluation throws").option("--retry <n>", "Retry failed evaluations up to N times").option("-q, --silent", "Suppress success output; only emit output on error").option("--interval <ms|duration>", "Polling interval (default: 250ms)").option("--count <n>", "Stop after N iterations").option("--total-timeout <duration>", "Max wall-clock time (e.g. 30s, 2m)").option("--verbose", "Print intermediate (falsy) results").option("-f, --file <path>", "Read expression from a file").option("--stdin", "Read expression from stdin").option("--iframe <selector>", "Eval in iframe via postMessage (requires helper script)").option("--iframe-namespace <name>", "Message type prefix for iframe eval (default: argus)").option("--iframe-timeout <ms>", "Timeout for iframe postMessage response (default: 5000)").option("--arg <key=value>", "Argument exposed to eval scripts as args[key]", collectValue, []).addHelpText("after", `
+  program2.command("eval-until").alias("wait").argument("[id]", "Watcher id to query").argument("[expression]", "JS expression to poll until truthy (or use --file / --stdin)").description("Poll a JS expression until it returns a truthy value").option("--no-await", "Do not await promises").option("--timeout <ms>", "Per-eval timeout in milliseconds").option("--json", "Output JSON for automation").option("--no-return-by-value", "Disable returnByValue (use preview)").option("--no-fail-on-exception", "Do not exit with code 1 when the evaluation throws").option("--retry <n>", "Retry failed evaluations up to N times").option("-q, --silent", "Suppress success output; only emit output on error").option("--interval <ms|duration>", "Polling interval (default: 250ms)").option("--count <n>", "Stop after N iterations").option("--total-timeout <duration>", "Max wall-clock time (e.g. 30s, 2m)").option("--verbose", "Print intermediate (falsy) results").option("-f, --file <path>", "Read expression from a file").option("--bundle", "Bundle local imports from --file into one script before eval").option("--stdin", "Read expression from stdin").option("--inject <path>", "Read setup code from a file and run it before the expression").option("--iframe <selector>", "Eval in iframe via postMessage (requires helper script)").option("--iframe-namespace <name>", "Message type prefix for iframe eval (default: argus)").option("--iframe-timeout <ms>", "Timeout for iframe postMessage response (default: 5000)").option("--arg <key=value>", "Argument exposed to eval scripts as args[key]", collectValue, []).addHelpText("after", `
 Examples:
   $ argus eval-until app "document.querySelector('#loaded')"
   $ argus eval-until app "await window.appReadyPromise"
@@ -20964,6 +21178,8 @@ Examples:
   $ argus eval-until app "window.data" --verbose
   $ argus eval-until app "window.data" --count 20 --interval 1s
   $ argus eval-until app --file ./check.js --total-timeout 1m
+  $ argus eval-until app --file ./check.js --bundle --total-timeout 1m
+  $ argus wait app "window.appReady" --inject ./debug-hooks.js --total-timeout 20s
   $ argus wait app --file ./ready.js --arg level=10 --total-timeout 20s
 `).action(async (id, expression, options) => {
     await runEvalUntil(id, expression, {
@@ -20979,7 +21195,9 @@ Examples:
       totalTimeout: options.totalTimeout,
       verbose: options.verbose,
       file: options.file,
+      bundle: options.bundle,
       stdin: options.stdin,
+      inject: options.inject,
       iframe: options.iframe,
       iframeNamespace: options.iframeNamespace,
       iframeTimeout: options.iframeTimeout,
@@ -21072,26 +21290,35 @@ var escapeAttrValue = (value) => {
 };
 
 // dist/commands/domTree.js
-var runDomTree = async (id, options) => {
-  const output = createOutput(options);
+var runDomTree = defineWatcherCommand({
+  build: (_args, options, output) => buildDomTreePlan(options, output),
+  formatHuman: (response, { output, options }) => {
+    if (response.matches === 0) {
+      writeNoElementFound(options.selector, output);
+      return;
+    }
+    const formatted = formatDomTree(response.roots, response.truncated, response.truncatedReason);
+    output.writeHuman(formatted);
+  }
+});
+var buildDomTreePlan = (options, output) => {
   const selector = requireSelector(options, output);
   if (!selector) {
-    return;
+    return null;
   }
   const depth = parsePositiveInt(options.depth, { allowZero: true });
   if (options.depth !== undefined && depth === undefined) {
     output.writeWarn("--depth must be a non-negative integer");
     process.exitCode = 2;
-    return;
+    return null;
   }
   const maxNodes = parsePositiveInt(options.maxNodes);
   if (options.maxNodes !== undefined && maxNodes === undefined) {
     output.writeWarn("--max-nodes must be a positive integer");
     process.exitCode = 2;
-    return;
+    return null;
   }
-  const result = await requestWatcherAction({
-    id,
+  return {
     path: "/dom/tree",
     method: "POST",
     body: {
@@ -21102,38 +21329,34 @@ var runDomTree = async (id, options) => {
       text: options.text
     },
     timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
-  if (successResp.matches === 0) {
-    writeNoElementFound(selector, output);
-    return;
-  }
-  const formatted = formatDomTree(successResp.roots, successResp.truncated, successResp.truncatedReason);
-  output.writeHuman(formatted);
+  };
 };
 
 // dist/commands/domInfo.js
-var runDomInfo = async (id, options) => {
-  const output = createOutput(options);
+var runDomInfo = defineWatcherCommand({
+  build: (_args, options, output) => buildDomInfoPlan(options, output),
+  formatHuman: (response, { output, options }) => {
+    const target = { selector: options.selector, ref: options.ref };
+    if (response.matches === 0) {
+      writeNoElementFound(target.selector ?? target.ref, output);
+      return;
+    }
+    const formatted = formatDomInfo(response.elements);
+    output.writeHuman(formatted);
+  }
+});
+var buildDomInfoPlan = (options, output) => {
   const target = requireElementTarget({ selector: options.selector, ref: options.ref }, output);
   if (!target) {
-    return;
+    return null;
   }
   const outerHtmlMaxChars = parsePositiveInt(options.outerHtmlMax);
   if (options.outerHtmlMax !== undefined && outerHtmlMaxChars === undefined) {
     output.writeWarn("--outer-html-max must be a positive integer");
     process.exitCode = 2;
-    return;
+    return null;
   }
-  const result = await requestWatcherAction({
-    id,
+  return {
     path: "/dom/info",
     method: "POST",
     body: {
@@ -21144,21 +21367,7 @@ var runDomInfo = async (id, options) => {
       text: options.text
     },
     timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
-  if (successResp.matches === 0) {
-    writeNoElementFound(target.selector ?? target.ref, output);
-    return;
-  }
-  const formatted = formatDomInfo(successResp.elements);
-  output.writeHuman(formatted);
+  };
 };
 
 // dist/commands/domFocus.js
@@ -21191,50 +21400,62 @@ var runDomFocus = defineWatcherCommand({
 
 // dist/commands/domAdd.js
 import { readFile as readFile3 } from "node:fs/promises";
-var runDomAdd = async (id, options) => {
-  const output = createOutput(options);
+var runDomAdd = defineWatcherCommand({
+  build: (_args, options, output) => buildDomAddPlan(options, output),
+  formatHuman: (successResp, { output, options, watcher }) => {
+    const selector = options.selector;
+    const position = normalizePosition(options.position);
+    if (successResp.matches === 0) {
+      writeNoElementFound(selector, output, `Hint: run \`argus dom tree ${watcher.id} --selector "${selector}" --all\``);
+      return;
+    }
+    const label = successResp.inserted === 1 ? "element" : "elements";
+    const prefix = watcher.id ? `${watcher.id}: ` : "";
+    output.writeHuman(`${prefix}Inserted at ${successResp.inserted}/${successResp.matches} ${label} (${position}) for selector: ${selector}`);
+  }
+});
+var buildDomAddPlan = async (options, output) => {
   const selector = requireSelector(options, output);
   if (!selector) {
-    return;
+    return null;
   }
   const position = normalizePosition(options.position);
   if (!position) {
     output.writeWarn("--position must be one of: beforebegin, afterbegin, beforeend, afterend (aliases: before, after, prepend, append)");
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (options.all && (options.nth != null || options.first)) {
     output.writeWarn("Cannot combine --all with --nth or --first");
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (options.nth != null && options.first) {
     output.writeWarn("Cannot combine --nth with --first");
     process.exitCode = 2;
-    return;
+    return null;
   }
   const nth = options.first ? 0 : parseNonNegativeInt(options.nth, "--nth", output);
   if (options.nth != null && nth == null) {
     process.exitCode = 2;
-    return;
+    return null;
   }
   const expect = parseNonNegativeInt(options.expect, "--expect", output);
   if (options.expect != null && expect == null) {
     process.exitCode = 2;
-    return;
+    return null;
   }
   const html = await resolveHtmlInput(options, output);
   if (html == null) {
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (!html) {
     output.writeWarn("HTML content is empty. Provide non-empty --html, --html-file, or --html-stdin input.");
     process.exitCode = 2;
-    return;
+    return null;
   }
-  const result = await requestWatcherAction({
-    id,
+  return {
     path: "/dom/add",
     method: "POST",
     body: {
@@ -21247,22 +21468,7 @@ var runDomAdd = async (id, options) => {
       text: options.text ?? false
     },
     timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
-  if (successResp.matches === 0) {
-    writeNoElementFound(selector, output, `Hint: run \`argus dom tree${id ? ` ${id}` : ""} --selector "${selector}" --all\``);
-    return;
-  }
-  const label = successResp.inserted === 1 ? "element" : "elements";
-  const prefix = result.watcher.id ? `${result.watcher.id}: ` : "";
-  output.writeHuman(`${prefix}Inserted at ${successResp.inserted}/${successResp.matches} ${label} (${position}) for selector: ${selector}`);
+  };
 };
 var normalizePosition = (value) => {
   if (!value) {
@@ -21591,25 +21797,28 @@ var buildSetFilePlan = (options, output) => {
 };
 
 // dist/commands/domScroll.js
-var runDomScroll = async (id, options) => {
-  const output = createOutput(options);
+var runDomScroll = defineWatcherCommand({
+  build: (_args, options, output) => buildDomScrollPlan(options, output),
+  formatHuman: formatDomScrollHuman
+});
+var buildDomScrollPlan = (options, output) => {
   if (options.by == null) {
     output.writeWarn("--by is required (e.g. --by 0,300)");
     process.exitCode = 2;
-    return;
+    return null;
   }
   const delta = parseXY(options.by);
   if (!delta) {
     output.writeWarn('--by must be in the format "x,y" (e.g. --by 0,300)');
     process.exitCode = 2;
-    return;
+    return null;
   }
   const hasSelector = options.selector != null && options.selector.trim() !== "";
   const hasPos = options.pos != null;
   if (hasSelector && hasPos) {
     output.writeWarn("--selector and --pos are mutually exclusive");
     process.exitCode = 2;
-    return;
+    return null;
   }
   let x;
   let y;
@@ -21618,7 +21827,7 @@ var runDomScroll = async (id, options) => {
     if (!parsed) {
       output.writeWarn('--pos must be in the format "x,y" (e.g. --pos 400,300)');
       process.exitCode = 2;
-      return;
+      return null;
     }
     x = parsed.x;
     y = parsed.y;
@@ -21635,21 +21844,12 @@ var runDomScroll = async (id, options) => {
     body.x = x;
     body.y = y;
   }
-  const result = await requestWatcherAction({
-    id,
-    path: "/dom/scroll",
-    method: "POST",
-    body,
-    timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
+  return { path: "/dom/scroll", method: "POST", body, timeoutMs: 30000 };
+};
+function formatDomScrollHuman(successResp, { output, options }) {
+  const delta = parseXY(options.by);
+  const hasSelector = options.selector != null && options.selector.trim() !== "";
+  const hasPos = options.pos != null;
   if (hasSelector) {
     if (successResp.matches === 0) {
       writeNoElementFound(options.selector, output);
@@ -21658,27 +21858,31 @@ var runDomScroll = async (id, options) => {
     const label = successResp.scrolled === 1 ? "element" : "elements";
     output.writeHuman(`Emulated scroll on ${successResp.scrolled} ${label} by (${delta.x}, ${delta.y})`);
   } else if (hasPos) {
+    const { x, y } = parseXY(options.pos);
     output.writeHuman(`Emulated scroll at (${x}, ${y}) by (${delta.x}, ${delta.y})`);
   } else {
     output.writeHuman(`Emulated scroll at viewport center by (${delta.x}, ${delta.y})`);
   }
-};
+}
 
 // dist/commands/domScrollTo.js
-var runDomScrollTo = async (id, options) => {
-  const output = createOutput(options);
+var runDomScrollTo = defineWatcherCommand({
+  build: (_args, options, output) => buildDomScrollToPlan(options, output),
+  formatHuman: formatDomScrollToHuman
+});
+var buildDomScrollToPlan = (options, output) => {
   const hasSelector = options.selector != null && options.selector.trim() !== "";
   const hasTo = options.to != null;
   const hasBy = options.by != null;
   if (!hasSelector && !hasTo && !hasBy) {
     output.writeWarn("--selector, --to, or --by is required");
     process.exitCode = 2;
-    return;
+    return null;
   }
   if (hasTo && hasBy) {
     output.writeWarn("--to and --by are mutually exclusive");
     process.exitCode = 2;
-    return;
+    return null;
   }
   let to;
   let by;
@@ -21687,7 +21891,7 @@ var runDomScrollTo = async (id, options) => {
     if (!parsed) {
       output.writeWarn('--to must be in the format "x,y" (e.g. --to 0,1000)');
       process.exitCode = 2;
-      return;
+      return null;
     }
     to = parsed;
   }
@@ -21696,7 +21900,7 @@ var runDomScrollTo = async (id, options) => {
     if (!parsed) {
       output.writeWarn('--by must be in the format "x,y" (e.g. --by 0,500)');
       process.exitCode = 2;
-      return;
+      return null;
     }
     by = parsed;
   }
@@ -21714,21 +21918,10 @@ var runDomScrollTo = async (id, options) => {
   if (by) {
     body.by = by;
   }
-  const result = await requestWatcherAction({
-    id,
-    path: "/dom/scroll-to",
-    method: "POST",
-    body,
-    timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
+  return { path: "/dom/scroll-to", method: "POST", body, timeoutMs: 30000 };
+};
+function formatDomScrollToHuman(successResp, { output, options }) {
+  const hasSelector = options.selector != null && options.selector.trim() !== "";
   if (hasSelector && successResp.matches === 0) {
     writeNoElementFound(options.selector, output);
     return;
@@ -21739,40 +21932,37 @@ var runDomScrollTo = async (id, options) => {
   } else {
     output.writeHuman(`Scrolled viewport (scrollX=${successResp.scrollX}, scrollY=${successResp.scrollY})`);
   }
-};
+}
 
 // dist/commands/domModify.js
 var executeModify = async (id, options, payload, successMessage) => {
-  const output = createOutput(options);
-  const selector = requireSelector(options, output);
-  if (!selector) {
-    return;
-  }
-  const result = await requestWatcherAction({
-    id,
-    path: "/dom/modify",
-    method: "POST",
-    body: {
-      ...payload,
-      selector,
-      ...options.text != null ? { text: options.text } : {}
-    },
-    timeoutMs: 30000
-  }, output);
-  if (!result) {
-    return;
-  }
-  const successResp = result.data;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
-  }
-  if (successResp.matches === 0) {
-    writeNoElementFound(selector, output);
-    return;
-  }
-  output.writeHuman(successMessage(successResp));
+  await runDomModifyRequest(id, payload, successMessage, options);
 };
+var runDomModifyRequest = defineWatcherCommand({
+  build: ([payload], options, output) => {
+    const selector = requireSelector(options, output);
+    if (!selector) {
+      return null;
+    }
+    return {
+      path: "/dom/modify",
+      method: "POST",
+      body: {
+        ...payload,
+        selector,
+        ...options.text != null ? { text: options.text } : {}
+      },
+      timeoutMs: 30000
+    };
+  },
+  formatHuman: (successResp, { output, options, args }) => {
+    if (successResp.matches === 0) {
+      writeNoElementFound(options.selector, output);
+      return;
+    }
+    output.writeHuman(args[1](successResp));
+  }
+});
 var parseAttrArgs = (attrs) => {
   const result = {};
   for (const attr of attrs) {
@@ -22150,47 +22340,28 @@ Examples:
 }
 
 // dist/commands/domKeydown.js
-var runDomKeydown = async (id, options) => {
-  const output = createOutput(options);
-  if (!options.key || options.key.trim() === "") {
-    output.writeWarn("--key is required");
-    process.exitCode = 2;
-    return;
-  }
-  const result = await requestWatcherJson({
-    id,
-    path: "/dom/keydown",
-    method: "POST",
-    body: {
-      key: options.key,
-      selector: options.selector,
-      modifiers: options.modifiers
-    },
-    timeoutMs: 30000,
-    returnErrorResponse: true
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  const response = result.data;
-  if (!response.ok) {
-    const errorResp = response;
-    if (options.json) {
-      output.writeJson(response);
-    } else {
-      output.writeWarn(`Error: ${errorResp.error.message}`);
+var runDomKeydown = defineWatcherCommand({
+  build: (_args, options, output) => {
+    if (!options.key || options.key.trim() === "") {
+      output.writeWarn("--key is required");
+      process.exitCode = 2;
+      return null;
     }
-    process.exitCode = 1;
-    return;
-  }
-  const successResp = response;
-  if (options.json) {
-    output.writeJson(successResp);
-    return;
+    return {
+      path: "/dom/keydown",
+      method: "POST",
+      body: {
+        key: options.key,
+        selector: options.selector,
+        modifiers: options.modifiers
+      },
+      timeoutMs: 30000
+    };
+  },
+  formatHuman: (response, { output }) => {
+    output.writeHuman(`Dispatched keydown: ${response.key}`);
   }
-  output.writeHuman(`Dispatched keydown: ${successResp.key}`);
-};
+});
 
 // dist/cli/register/registerKeydown.js
 function registerKeydown(program2) {
@@ -22531,19 +22702,23 @@ Examples:
 
 // dist/commands/screenshot.js
 var SCREENSHOT_REQUEST_TIMEOUT_MS = 45000;
-var runScreenshot = async (id, options) => {
-  const output = createOutput(options);
+var runScreenshot = defineWatcherCommand({
+  build: (_args, options, output) => buildScreenshotPlan(options, output),
+  formatHuman: (response, { output }) => {
+    output.writeHuman(`Screenshot saved: ${response.outFile}`);
+  }
+});
+var buildScreenshotPlan = (options, output) => {
   const clip = parseScreenshotClip(options.clip, output);
   if (clip === null) {
-    return;
+    return null;
   }
   const selector = normalizeSelector(options.selector);
   if (selector && clip) {
     writeScreenshotOptionError(output, "Cannot use both --selector and --clip");
-    return;
+    return null;
   }
-  const result = await requestWatcherJson({
-    id,
+  return {
     path: "/screenshot",
     method: "POST",
     body: {
@@ -22553,16 +22728,7 @@ var runScreenshot = async (id, options) => {
       format: "png"
     },
     timeoutMs: SCREENSHOT_REQUEST_TIMEOUT_MS
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return;
-  }
-  if (options.json) {
-    output.writeJson(result.data);
-    return;
-  }
-  output.writeHuman(`Screenshot saved: ${result.data.outFile}`);
+  };
 };
 var normalizeSelector = (selector) => {
   const trimmed = selector?.trim();
@@ -22844,12 +23010,13 @@ function resolveActionOptions(options, command) {
 
 // dist/commands/configInit.js
 import fs12 from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_CONFIG_PATH = ".argus/config.json";
 var buildConfigTemplate = (schemaRef) => ({
   $schema: schemaRef,
   plugins: [],
+  pluginAliases: {},
   chrome: {
     start: {
       url: "http://localhost:3000",
@@ -22870,12 +23037,12 @@ var buildConfigTemplate = (schemaRef) => ({
 });
 var resolveConfigPath = (cwd, targetPath) => {
   if (!targetPath) {
-    return path12.resolve(cwd, DEFAULT_CONFIG_PATH);
+    return path13.resolve(cwd, DEFAULT_CONFIG_PATH);
   }
-  return path12.isAbsolute(targetPath) ? targetPath : path12.resolve(cwd, targetPath);
+  return path13.isAbsolute(targetPath) ? targetPath : path13.resolve(cwd, targetPath);
 };
 var ensureParentDir2 = async (filePath) => {
-  const dir = path12.dirname(filePath);
+  const dir = path13.dirname(filePath);
   try {
     await fs12.mkdir(dir, { recursive: true });
     return true;
@@ -22954,33 +23121,33 @@ Examples:
   });
 }
 
-// dist/commands/extension/setup.js
-import fs14 from "node:fs";
-import { execSync as execSync2 } from "node:child_process";
-
 // dist/commands/extension/nativeHost.js
 import fs13 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import os4 from "node:os";
 import { execSync } from "node:child_process";
-var HOST_NAME = "com.vforsh.argus.bridge";
+var BRIDGE_HOST_NAME = "com.vforsh.argus.bridge";
+var CONTROL_HOST_NAME = "com.vforsh.argus.control";
+var CONTROL_WATCHER_ID = "extension-control";
+var HOST_NAMES = [BRIDGE_HOST_NAME, CONTROL_HOST_NAME];
 var getManifestDir = (platform) => {
   switch (platform) {
     case "darwin":
-      return path13.join(os4.homedir(), "Library/Application Support/Google/Chrome/NativeMessagingHosts");
+      return path14.join(os4.homedir(), "Library/Application Support/Google/Chrome/NativeMessagingHosts");
     case "linux":
-      return path13.join(os4.homedir(), ".config/google-chrome/NativeMessagingHosts");
+      return path14.join(os4.homedir(), ".config/google-chrome/NativeMessagingHosts");
     case "win32":
-      return path13.join(process.env.LOCALAPPDATA ?? os4.homedir(), "Google/Chrome/User Data/NativeMessagingHosts");
+      return path14.join(process.env.LOCALAPPDATA ?? os4.homedir(), "Google/Chrome/User Data/NativeMessagingHosts");
     default:
       throw new Error(`Unsupported platform: ${platform}`);
   }
 };
-var getManifestPath = (platform) => {
-  return path13.join(getManifestDir(platform), `${HOST_NAME}.json`);
+var getManifestPath = (platform, hostName = BRIDGE_HOST_NAME) => {
+  return path14.join(getManifestDir(platform), `${hostName}.json`);
 };
-var getWrapperPath = (platform) => {
-  return path13.join(getManifestDir(platform), "argus-native-host.sh");
+var getWrapperPath = (platform, hostName = BRIDGE_HOST_NAME) => {
+  const filename = hostName === CONTROL_HOST_NAME ? "argus-native-control-host.sh" : "argus-native-host.sh";
+  return path14.join(getManifestDir(platform), filename);
 };
 var getPlatform = () => {
   const platform = os4.platform();
@@ -22992,7 +23159,7 @@ var getPlatform = () => {
 var findArgusExecutable = () => {
   try {
     const npmGlobalPrefix = execSync("npm config get prefix", { encoding: "utf8" }).trim();
-    const globalBinPath = path13.join(npmGlobalPrefix, "bin", "argus");
+    const globalBinPath = path14.join(npmGlobalPrefix, "bin", "argus");
     if (fs13.existsSync(globalBinPath)) {
       return globalBinPath;
     }
@@ -23008,25 +23175,71 @@ var findArgusExecutable = () => {
 var findNodePath = () => {
   return fs13.realpathSync(process.execPath);
 };
-var createManifest = (extensionId, executablePath) => {
+var createManifest = (extensionId, executablePath, hostName = BRIDGE_HOST_NAME) => {
   return {
-    name: HOST_NAME,
-    description: "Argus Watcher Native Messaging Host",
+    name: hostName,
+    description: hostName === CONTROL_HOST_NAME ? "Argus Extension Control Native Messaging Host" : "Argus Watcher Native Messaging Host",
     path: executablePath,
     type: "stdio",
     allowed_origins: [`chrome-extension://${extensionId}/`]
   };
 };
-var createWrapperScript = (platform, executablePath) => {
-  const wrapperDir = getManifestDir(platform);
-  const wrapperPath = path13.join(wrapperDir, "argus-native-host.sh");
+var createWrapperScript = (platform, executablePath, hostName = BRIDGE_HOST_NAME) => {
+  const wrapperPath = getWrapperPath(platform, hostName);
   const nodePath = findNodePath();
+  const args = hostName === CONTROL_HOST_NAME ? `watcher native-host --role control --id ${CONTROL_WATCHER_ID}` : "watcher native-host --role tab";
   const script = `#!/bin/bash
-exec "${nodePath}" "${executablePath}" watcher native-host
+exec "${nodePath}" "${executablePath}" ${args}
 `;
   fs13.writeFileSync(wrapperPath, script, { mode: 493 });
   return wrapperPath;
 };
+var installNativeHosts = (platform, extensionId, executablePath) => {
+  fs13.mkdirSync(getManifestDir(platform), { recursive: true });
+  return HOST_NAMES.map((hostName) => {
+    const wrapperPath = createWrapperScript(platform, executablePath, hostName);
+    const manifestPath = getManifestPath(platform, hostName);
+    const manifest = createManifest(extensionId, wrapperPath, hostName);
+    fs13.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    registerWindowsNativeHost(platform, hostName, manifestPath);
+    return { hostName, manifestPath, wrapperPath };
+  });
+};
+var inspectNativeHosts = (platform) => {
+  return HOST_NAMES.map((hostName) => inspectNativeHost(platform, hostName));
+};
+var removeNativeHosts = (platform) => {
+  return HOST_NAMES.map((hostName) => {
+    const host = inspectNativeHost(platform, hostName);
+    const manifestRemoved = removeFileIfExists(host.manifestPath);
+    const wrapperRemoved = removeFileIfExists(host.wrapperPath);
+    unregisterWindowsNativeHost(platform, hostName);
+    return { ...host, manifestRemoved, wrapperRemoved };
+  });
+};
+var inspectNativeHost = (platform, hostName) => {
+  const manifestPath = getManifestPath(platform, hostName);
+  const wrapperPath = getWrapperPath(platform, hostName);
+  const manifestExists = fs13.existsSync(manifestPath);
+  const wrapperExists = fs13.existsSync(wrapperPath);
+  const wrapperExecutable = wrapperExists && isWrapperExecutable(wrapperPath);
+  const manifest = manifestExists ? readManifest(manifestPath) : null;
+  const manifestValid = Boolean(manifest && manifest.name === hostName && manifest.type === "stdio" && Array.isArray(manifest.allowed_origins));
+  const extensionId = extractExtensionId(manifest?.allowed_origins?.[0]);
+  return {
+    hostName,
+    manifestPath,
+    wrapperPath,
+    manifestExists,
+    manifestValid,
+    wrapperExists,
+    wrapperExecutable,
+    configured: manifestExists && manifestValid && wrapperExists && wrapperExecutable,
+    installed: manifestExists && wrapperExists,
+    extensionId,
+    argusPath: manifest?.path ?? null
+  };
+};
 var readManifest = (manifestPath) => {
   try {
     const content = fs13.readFileSync(manifestPath, "utf8");
@@ -23050,6 +23263,36 @@ var shortenPath = (filePath) => {
   }
   return filePath;
 };
+var extractExtensionId = (origin) => {
+  if (!origin) {
+    return null;
+  }
+  const match = origin.match(/^chrome-extension:\/\/([^/]+)\/$/);
+  return match?.[1] ?? null;
+};
+var removeFileIfExists = (filePath) => {
+  if (!fs13.existsSync(filePath)) {
+    return false;
+  }
+  fs13.unlinkSync(filePath);
+  return true;
+};
+var registerWindowsNativeHost = (platform, hostName, manifestPath) => {
+  if (platform !== "win32") {
+    return;
+  }
+  const regKey = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`;
+  execSync(`reg add "${regKey}" /ve /t REG_SZ /d "${manifestPath}" /f`, { stdio: "pipe" });
+};
+var unregisterWindowsNativeHost = (platform, hostName) => {
+  if (platform !== "win32") {
+    return;
+  }
+  const regKey = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${hostName}`;
+  try {
+    execSync(`reg delete "${regKey}" /f`, { stdio: "pipe" });
+  } catch {}
+};
 
 // dist/commands/extension/setup.js
 var runExtensionSetup = async (options) => {
@@ -23067,10 +23310,6 @@ var runExtensionSetup = async (options) => {
     process.exitCode = 1;
     return;
   }
-  const manifestDir = getManifestDir(platform);
-  const manifestPath = getManifestPath(platform);
-  const wrapperPath = getWrapperPath(platform);
-  fs14.mkdirSync(manifestDir, { recursive: true });
   let executablePath;
   try {
     executablePath = findArgusExecutable();
@@ -23083,51 +23322,44 @@ var runExtensionSetup = async (options) => {
     process.exitCode = 1;
     return;
   }
-  createWrapperScript(platform, executablePath);
-  const manifest = createManifest(extensionId, wrapperPath);
-  fs14.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  if (platform === "win32") {
-    const regKey = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${HOST_NAME}`;
-    try {
-      execSync2(`reg add "${regKey}" /ve /t REG_SZ /d "${manifestPath}" /f`, { stdio: "pipe" });
-    } catch (error) {
-      if (options.json) {
-        output.writeJson({ success: false, error: `Failed to add registry key: ${error.message}` });
-      } else {
-        console.error("Failed to add registry key:", error);
-      }
-      process.exitCode = 1;
-      return;
+  let installedHosts;
+  try {
+    installedHosts = installNativeHosts(platform, extensionId, executablePath);
+  } catch (error) {
+    if (options.json) {
+      output.writeJson({ success: false, error: `Failed to install native hosts: ${error.message}` });
+    } else {
+      console.error("Failed to install native hosts:", error);
     }
+    process.exitCode = 1;
+    return;
   }
   if (options.json) {
     output.writeJson({
       success: true,
-      hostName: HOST_NAME,
       extensionId,
-      manifestPath,
-      wrapperPath,
+      hosts: installedHosts,
       argusPath: executablePath
     });
   } else {
     output.writeHuman("");
-    output.writeHuman("Native messaging host installed");
+    output.writeHuman("Native messaging hosts installed");
     output.writeHuman("");
-    output.writeHuman(`  Host name:    ${HOST_NAME}`);
     output.writeHuman(`  Extension ID: ${extensionId}`);
-    output.writeHuman(`  Manifest:     ${shortenPath(manifestPath)}`);
-    output.writeHuman(`  Wrapper:      ${shortenPath(wrapperPath)}`);
+    for (const host of installedHosts) {
+      output.writeHuman(`  Host name:    ${host.hostName}`);
+      output.writeHuman(`  Manifest:     ${shortenPath(host.manifestPath)}`);
+      output.writeHuman(`  Wrapper:      ${shortenPath(host.wrapperPath)}`);
+    }
     output.writeHuman("");
     output.writeHuman("Next steps:");
     output.writeHuman("  1. Reload the extension in chrome://extensions");
-    output.writeHuman("  2. Open the extension popup and attach a tab");
+    output.writeHuman("  2. Run `argus ext tabs` or open the extension popup and attach a tab");
     output.writeHuman("");
   }
 };
 
 // dist/commands/extension/remove.js
-import fs15 from "node:fs";
-import { execSync as execSync3 } from "node:child_process";
 var runExtensionRemove = async (options) => {
   const output = createOutput(options);
   let platform;
@@ -23142,55 +23374,42 @@ var runExtensionRemove = async (options) => {
     process.exitCode = 1;
     return;
   }
-  const manifestPath = getManifestPath(platform);
-  const wrapperPath = getWrapperPath(platform);
-  let manifestRemoved = false;
-  let wrapperRemoved = false;
-  if (fs15.existsSync(manifestPath)) {
-    fs15.unlinkSync(manifestPath);
-    manifestRemoved = true;
-  }
-  if (fs15.existsSync(wrapperPath)) {
-    fs15.unlinkSync(wrapperPath);
-    wrapperRemoved = true;
-  }
-  if (platform === "win32") {
-    const regKey = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${HOST_NAME}`;
-    try {
-      execSync3(`reg delete "${regKey}" /f`, { stdio: "pipe" });
-    } catch {}
-  }
+  const removedHosts = removeNativeHosts(platform);
+  const manifestRemoved = removedHosts.some((host) => host.manifestRemoved);
+  const wrapperRemoved = removedHosts.some((host) => host.wrapperRemoved);
   if (options.json) {
     output.writeJson({
       success: true,
       manifestRemoved,
       wrapperRemoved,
-      manifestPath,
-      wrapperPath
+      hosts: removedHosts
     });
   } else {
     output.writeHuman("");
     if (manifestRemoved || wrapperRemoved) {
-      output.writeHuman("Native messaging host removed");
+      output.writeHuman("Native messaging hosts removed");
       output.writeHuman("");
-      if (manifestRemoved) {
-        output.writeHuman(`  Removed manifest: ${shortenPath(manifestPath)}`);
-      }
-      if (wrapperRemoved) {
-        output.writeHuman(`  Removed wrapper:  ${shortenPath(wrapperPath)}`);
+      for (const host of removedHosts) {
+        if (host.manifestRemoved) {
+          output.writeHuman(`  Removed manifest: ${shortenPath(host.manifestPath)}`);
+        }
+        if (host.wrapperRemoved) {
+          output.writeHuman(`  Removed wrapper:  ${shortenPath(host.wrapperPath)}`);
+        }
       }
     } else {
-      output.writeHuman("Native messaging host was not installed");
+      output.writeHuman("Native messaging hosts were not installed");
       output.writeHuman("");
-      output.writeHuman(`  Manifest not found: ${shortenPath(manifestPath)}`);
-      output.writeHuman(`  Wrapper not found:  ${shortenPath(wrapperPath)}`);
+      for (const host of removedHosts) {
+        output.writeHuman(`  Manifest not found: ${shortenPath(host.manifestPath)}`);
+        output.writeHuman(`  Wrapper not found:  ${shortenPath(host.wrapperPath)}`);
+      }
     }
     output.writeHuman("");
   }
 };
 
 // dist/commands/extension/status.js
-import fs16 from "node:fs";
 var runExtensionStatus = async (options) => {
   const output = createOutput(options);
   let platform;
@@ -23205,40 +23424,14 @@ var runExtensionStatus = async (options) => {
     process.exitCode = 1;
     return;
   }
-  const manifestPath = getManifestPath(platform);
-  const wrapperPath = getWrapperPath(platform);
-  const manifestExists = fs16.existsSync(manifestPath);
-  const wrapperExists = fs16.existsSync(wrapperPath);
-  const wrapperExecutable = wrapperExists && isWrapperExecutable(wrapperPath);
-  let manifest = null;
-  let manifestValid = false;
-  let extensionId = null;
-  if (manifestExists) {
-    manifest = readManifest(manifestPath);
-    if (manifest && manifest.name === HOST_NAME && manifest.type === "stdio" && Array.isArray(manifest.allowed_origins)) {
-      manifestValid = true;
-      const origin = manifest.allowed_origins[0];
-      if (origin) {
-        const match = origin.match(/^chrome-extension:\/\/([^/]+)\/$/);
-        if (match) {
-          extensionId = match[1];
-        }
-      }
-    }
-  }
-  const configured = manifestExists && manifestValid && wrapperExists && wrapperExecutable;
+  const hosts = inspectNativeHosts(platform);
+  const configured = hosts.every((host) => host.configured);
+  const extensionId = hosts.find((host) => host.extensionId)?.extensionId ?? null;
   if (options.json) {
     output.writeJson({
       configured,
-      hostName: HOST_NAME,
-      manifestPath,
-      wrapperPath,
-      manifestExists,
-      manifestValid,
-      wrapperExists,
-      wrapperExecutable,
-      extensionId,
-      argusPath: manifest?.path ?? null
+      hosts,
+      extensionId
     });
     if (!configured) {
       process.exitCode = 1;
@@ -23247,16 +23440,17 @@ var runExtensionStatus = async (options) => {
   }
   output.writeHuman("");
   if (configured) {
-    output.writeHuman("Native messaging host is configured");
+    output.writeHuman("Native messaging hosts are configured");
     output.writeHuman("");
-    output.writeHuman(`  Manifest:     exists`);
-    output.writeHuman(`  Wrapper:      exists, executable`);
     output.writeHuman(`  Extension ID: ${extensionId}`);
   } else {
-    output.writeHuman("Native messaging host not configured");
+    output.writeHuman("Native messaging hosts not configured");
     output.writeHuman("");
-    output.writeHuman(`  Manifest:     ${manifestExists ? manifestValid ? "exists" : "exists, invalid" : "not found"}`);
-    output.writeHuman(`  Wrapper:      ${wrapperExists ? wrapperExecutable ? "exists, executable" : "exists, not executable" : "not found"}`);
+    for (const host of hosts) {
+      output.writeHuman(`  ${host.hostName}`);
+      output.writeHuman(`    Manifest: ${host.manifestExists ? host.manifestValid ? "exists" : "exists, invalid" : "not found"}`);
+      output.writeHuman(`    Wrapper:  ${host.wrapperExists ? host.wrapperExecutable ? "exists, executable" : "exists, not executable" : "not found"}`);
+    }
     if (extensionId) {
       output.writeHuman(`  Extension ID: ${extensionId}`);
     }
@@ -23268,7 +23462,6 @@ var runExtensionStatus = async (options) => {
 };
 
 // dist/commands/extension/info.js
-import fs17 from "node:fs";
 var runExtensionInfo = async (options) => {
   const output = createOutput(options);
   let platform;
@@ -23283,51 +23476,32 @@ var runExtensionInfo = async (options) => {
     process.exitCode = 1;
     return;
   }
-  const manifestPath = getManifestPath(platform);
-  const wrapperPath = getWrapperPath(platform);
-  const manifestExists = fs17.existsSync(manifestPath);
-  const wrapperExists = fs17.existsSync(wrapperPath);
-  let extensionId = null;
-  let argusPath = null;
-  if (manifestExists) {
-    const manifest = readManifest(manifestPath);
-    if (manifest) {
-      argusPath = manifest.path;
-      const origin = manifest.allowed_origins?.[0];
-      if (origin) {
-        const match = origin.match(/^chrome-extension:\/\/([^/]+)\/$/);
-        if (match) {
-          extensionId = match[1];
-        }
-      }
-    }
-  }
-  const installed = manifestExists && wrapperExists;
+  const hosts = inspectNativeHosts(platform);
+  const installed = hosts.every((host) => host.installed);
   if (options.json) {
     output.writeJson({
-      hostName: HOST_NAME,
       platform,
-      manifestPath,
-      wrapperPath,
       installed,
-      extensionId,
-      argusPath
+      hosts
     });
     return;
   }
   output.writeHuman("");
   output.writeHuman("Native Messaging Host Info");
   output.writeHuman("");
-  output.writeHuman(`  Host name:     ${HOST_NAME}`);
   output.writeHuman(`  Platform:      ${platform}`);
-  output.writeHuman(`  Manifest path: ${shortenPath(manifestPath)}`);
-  output.writeHuman(`  Wrapper path:  ${shortenPath(wrapperPath)}`);
+  for (const host of hosts) {
+    output.writeHuman(`  Host name:     ${host.hostName}`);
+    output.writeHuman(`  Manifest path: ${shortenPath(host.manifestPath)}`);
+    output.writeHuman(`  Wrapper path:  ${shortenPath(host.wrapperPath)}`);
+  }
   output.writeHuman("");
   output.writeHuman("Current configuration:");
   output.writeHuman(`  Installed:     ${installed ? "yes" : "no"}`);
-  if (installed) {
-    output.writeHuman(`  Extension ID:  ${extensionId ?? "(unknown)"}`);
-    output.writeHuman(`  Argus path:    ${argusPath ?? "(unknown)"}`);
+  for (const host of hosts.filter((entry) => entry.installed)) {
+    output.writeHuman(`  ${host.hostName}`);
+    output.writeHuman(`    Extension ID: ${host.extensionId ?? "(unknown)"}`);
+    output.writeHuman(`    Argus path:   ${host.argusPath ?? "(unknown)"}`);
   }
   output.writeHuman("");
 };
@@ -23355,38 +23529,23 @@ var resolveExtensionWatcher = async (input) => {
   if (extensionWatchers.length === 0) {
     return {
       ok: false,
-      error: "No extension-backed watchers found. Attach a tab in the extension popup first.",
+      error: "No extension-backed watchers found. Reload the extension after `argus extension setup`, or attach a tab in the extension popup.",
       exitCode: 2
     };
   }
-  const reachability = await Promise.all(extensionWatchers.map(async (watcher) => ({
-    watcher,
-    status: await checkWatcherStatus3(watcher)
-  })));
-  const attached = reachability.filter((entry) => entry.status.ok && entry.status.status.attached);
-  if (attached.length === 1) {
-    return { ok: true, watcher: attached[0].watcher, registry: registry2 };
-  }
-  const cwd = process.cwd();
-  const cwdMatches = extensionWatchers.filter((watcher) => watcher.cwd === cwd);
-  const attachedCwdMatches = attached.filter((entry) => entry.watcher.cwd === cwd);
-  if (attachedCwdMatches.length === 1) {
-    return { ok: true, watcher: attachedCwdMatches[0].watcher, registry: registry2 };
-  }
-  if (attached.length > 1) {
-    return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: attached.map((entry) => entry.watcher) };
-  }
-  if (cwdMatches.length === 1) {
-    return { ok: true, watcher: cwdMatches[0], registry: registry2 };
-  }
-  if (cwdMatches.length > 1) {
-    return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: cwdMatches };
-  }
-  const reachable = reachability.filter((entry) => entry.status.ok);
-  if (reachable.length === 1) {
-    return { ok: true, watcher: reachable[0].watcher, registry: registry2 };
+  const controlWatcher = registry2.watchers[CONTROL_WATCHER_ID];
+  if (controlWatcher?.source === "extension") {
+    const status = await checkWatcherStatus3(controlWatcher);
+    if (status.ok) {
+      return { ok: true, watcher: controlWatcher, registry: registry2 };
+    }
   }
-  return { ok: false, error: "Watcher id required.", exitCode: 2, candidates: extensionWatchers };
+  return {
+    ok: false,
+    error: "extension-control watcher is unavailable. Reload the extension after `argus extension setup`.",
+    exitCode: 2,
+    candidates: extensionWatchers
+  };
 };
 var getExtensionWatchers = (watchers) => watchers.filter((watcher) => watcher.source === "extension");
 var checkWatcherStatus3 = async (watcher) => {
@@ -23479,6 +23638,173 @@ var writeCommandError = (output, options, humanMessage, jsonPayload) => {
 };
 var formatError4 = (error) => error instanceof Error ? error.message : String(error);
 
+// dist/commands/extension/attach.js
+var runExtensionAttach = async (options) => {
+  await runExtensionTabAction("attach", options);
+};
+var runExtensionDetach = async (options) => {
+  await runExtensionTabAction("detach", options);
+};
+var runExtensionTabAction = async (action, options) => {
+  const output = createOutput(options);
+  const resolved = await resolveExtensionWatcher({});
+  if (!resolved.ok) {
+    writeResolveFailure2(output, options, resolved);
+    return;
+  }
+  const selector = parseTabSelector(options);
+  if (!selector.ok) {
+    writeTabResolutionFailure(output, options, selector);
+    return;
+  }
+  const tabs = await fetchTabs(resolved.watcher, selector.selector, output, options);
+  if (!tabs) {
+    return;
+  }
+  const tab = resolveTab(tabs, selector.selector);
+  if (!tab.ok) {
+    writeTabResolutionFailure(output, options, tab);
+    return;
+  }
+  let response;
+  try {
+    response = await fetchWatcherJson(resolved.watcher, {
+      path: action === "attach" ? "/attach" : "/detach",
+      method: "POST",
+      body: { tabId: tab.tab.tabId },
+      timeoutMs: 5000,
+      returnErrorResponse: true
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeCommandError2(output, options, `${resolved.watcher.id}: failed to ${action} tab (${message})`, message);
+    return;
+  }
+  if (!response.ok) {
+    writeCommandError2(output, options, `Error: ${response.error.message}`, response);
+    return;
+  }
+  if (options.json) {
+    output.writeJson({
+      ok: true,
+      tab: tab.tab,
+      watcherId: resolved.watcher.id
+    });
+    return;
+  }
+  const verb = action === "attach" ? "Attach" : "Detach";
+  output.writeHuman(`${verb} request sent via ${resolved.watcher.id}`);
+  output.writeHuman(`  ${formatExtensionTabLine2(tab.tab)}`);
+};
+var fetchTabs = async (watcher, selector, output, options) => {
+  const query = buildTabsQuery2(selector);
+  try {
+    const response = await fetchWatcherJson(watcher, {
+      path: "/tabs",
+      query,
+      timeoutMs: 5000,
+      returnErrorResponse: true
+    });
+    if (!response.ok) {
+      writeCommandError2(output, options, `Error: ${response.error.message}`, response);
+      return null;
+    }
+    return response.tabs;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeCommandError2(output, options, `${watcher.id}: failed to list extension tabs (${message})`, message);
+    return null;
+  }
+};
+var parseTabSelector = (options) => {
+  const tabId = parseTabId(options.tab);
+  const url = options.url?.trim();
+  const title = options.title?.trim();
+  if (tabId !== null && (url || title)) {
+    return { ok: false, reason: "Use --tab by itself, or resolve by --url/--title.", exitCode: 2 };
+  }
+  if (tabId === null && !url && !title) {
+    return { ok: false, reason: "Specify --tab <tabId>, --url <substring>, or --title <substring>.", exitCode: 2 };
+  }
+  if (options.tab != null && tabId === null) {
+    return { ok: false, reason: `Invalid --tab value: ${options.tab}`, exitCode: 2 };
+  }
+  if (tabId !== null) {
+    return { ok: true, selector: { kind: "tab", tabId } };
+  }
+  return { ok: true, selector: { kind: "query", url, title } };
+};
+var resolveTab = (tabs, selector) => {
+  const matches = selector.kind === "tab" ? tabs.filter((tab) => tab.tabId === selector.tabId) : tabs;
+  if (matches.length === 0) {
+    return { ok: false, reason: "No extension tab matched.", exitCode: 2 };
+  }
+  if (matches.length > 1) {
+    return { ok: false, reason: "Multiple extension tabs matched. Use --tab to pick one.", exitCode: 2, matches };
+  }
+  return { ok: true, tab: matches[0] };
+};
+var parseTabId = (value) => {
+  if (value === undefined) {
+    return null;
+  }
+  const tabId = typeof value === "number" ? value : Number(value);
+  return Number.isInteger(tabId) ? tabId : null;
+};
+var buildTabsQuery2 = (selector) => {
+  const query = new URLSearchParams;
+  if (selector.kind === "tab") {
+    return query;
+  }
+  if (selector.url) {
+    query.set("url", selector.url);
+  }
+  if (selector.title) {
+    query.set("title", selector.title);
+  }
+  return query;
+};
+var writeTabResolutionFailure = (output, options, result) => {
+  const matches = "matches" in result ? result.matches : undefined;
+  if (options.json) {
+    output.writeJson({ ok: false, error: result.reason, matches: matches ?? [] });
+  } else {
+    output.writeWarn(result.reason);
+    if (matches) {
+      for (const tab of matches) {
+        output.writeWarn(`  ${formatExtensionTabLine2(tab)}`);
+      }
+    }
+  }
+  process.exitCode = result.exitCode;
+};
+var writeResolveFailure2 = (output, options, resolved) => {
+  if (options.json) {
+    output.writeJson({ ok: false, error: resolved.error, candidates: resolved.candidates?.map((watcher) => watcher.id) ?? [] });
+  } else {
+    output.writeWarn(resolved.error);
+    if (resolved.candidates && resolved.candidates.length > 0) {
+      for (const watcher of resolved.candidates) {
+        output.writeWarn(formatWatcherLine(watcher));
+      }
+    }
+  }
+  process.exitCode = resolved.exitCode;
+};
+var writeCommandError2 = (output, options, humanMessage, jsonPayload) => {
+  if (options.json) {
+    output.writeJson(typeof jsonPayload === "string" ? { ok: false, error: jsonPayload } : jsonPayload);
+  } else {
+    output.writeWarn(humanMessage);
+  }
+  process.exitCode = 1;
+};
+var formatExtensionTabLine2 = (tab) => {
+  const state2 = tab.attached ? "attached" : "available";
+  const label = tab.title || "(untitled)";
+  return `${tab.tabId} [${state2}] ${label} - ${tab.url}`;
+};
+
 // dist/cli/register/registerExtension.js
 function registerExtension(program2) {
   const extension = program2.command("extension").alias("ext").description("Browser extension management");
@@ -23500,7 +23826,7 @@ To get your extension ID:
   extension.command("info").description("Show native messaging host paths and configuration").option("--json", "Output JSON for automation").action(async (options) => {
     await runExtensionInfo(options);
   });
-  extension.command("tabs").description("List browser tabs visible to the extension transport").option("--id <watcherId>", "Extension-backed watcher id to use as the transport").option("--url <substring>", "Filter tabs by URL substring").option("--title <substring>", "Filter tabs by title substring").option("--json", "Output JSON for automation").addHelpText("after", `
+  extension.command("tabs").description("List browser tabs visible to the extension transport").option("--id <watcherId>", "Extension-backed watcher id to use as the transport (default: extension-control)").option("--url <substring>", "Filter tabs by URL substring").option("--title <substring>", "Filter tabs by title substring").option("--json", "Output JSON for automation").addHelpText("after", `
 Examples:
   $ argus ext tabs
   $ argus ext tabs --url localhost
@@ -23509,6 +23835,22 @@ Examples:
 `).action(async (options) => {
     await runExtensionTabs(options);
   });
+  extension.command("attach").description("Ask the extension control watcher to attach a browser tab").option("--tab <tabId>", "Browser tab id to attach").option("--url <substring>", "Resolve tab by URL substring").option("--title <substring>", "Resolve tab by title substring").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus ext attach --tab 123
+  $ argus ext attach --url localhost
+  $ argus ext attach --title Docs --json
+`).action(async (options) => {
+    await runExtensionAttach(options);
+  });
+  extension.command("detach").description("Ask the extension control watcher to detach a browser tab").option("--tab <tabId>", "Browser tab id to detach").option("--url <substring>", "Resolve tab by URL substring").option("--title <substring>", "Resolve tab by title substring").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus ext detach --tab 123
+  $ argus ext detach --url localhost
+  $ argus ext detach --title Docs --json
+`).action(async (options) => {
+    await runExtensionDetach(options);
+  });
 }
 
 // dist/output/code.js
@@ -33771,7 +34113,7 @@ function hr2(a2, t, e) {
   }
   return t;
 }
-var fs18 = hr2;
+var fs14 = hr2;
 function cr2(a2, t) {
   return t === false ? false : a2.charAt(t) === "/" && a2.charAt(t + 1) === "/" ? ls(a2, t) : t;
 }
@@ -33779,7 +34121,7 @@ var ds = cr2;
 function lr2(a2, t) {
   let e = null, s = t;
   for (;s !== e; )
-    e = s, s = cs(a2, s), s = ps(a2, s), s = ds(a2, s), s = fs18(a2, s);
+    e = s, s = cs(a2, s), s = ps(a2, s), s = ds(a2, s), s = fs14(a2, s);
   return s;
 }
 var ms = lr2;
@@ -35779,13 +36121,13 @@ function kc({ node: e, parent: t }) {
   let r = /^[fx]?(?:describe|it|test)$/u;
   return t.type === "TaggedTemplateExpression" && t.quasi === e && t.tag.type === "MemberExpression" && t.tag.property.type === "Identifier" && t.tag.property.name === "each" && (t.tag.object.type === "Identifier" && r.test(t.tag.object.name) || t.tag.object.type === "MemberExpression" && t.tag.object.property.type === "Identifier" && (t.tag.object.property.name === "only" || t.tag.object.property.name === "skip") && t.tag.object.object.type === "Identifier" && r.test(t.tag.object.object.name));
 }
-var fs19 = [(e, t) => e.type === "ObjectExpression" && t === "properties", (e, t) => e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component" && t === "arguments", (e, t) => e.type === "Decorator" && t === "expression"];
+var fs15 = [(e, t) => e.type === "ObjectExpression" && t === "properties", (e, t) => e.type === "CallExpression" && e.callee.type === "Identifier" && e.callee.name === "Component" && t === "arguments", (e, t) => e.type === "Decorator" && t === "expression"];
 function oo2(e) {
   let t = (n) => n.type === "TemplateLiteral", r = (n, s) => Oe3(n) && !n.computed && n.key.type === "Identifier" && n.key.name === "styles" && s === "value";
-  return e.match(t, (n, s) => q3(n) && s === "elements", r, ...fs19) || e.match(t, r, ...fs19);
+  return e.match(t, (n, s) => q3(n) && s === "elements", r, ...fs15) || e.match(t, r, ...fs15);
 }
 function ys2(e) {
-  return e.match((t) => t.type === "TemplateLiteral", (t, r) => Oe3(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...fs19);
+  return e.match((t) => t.type === "TemplateLiteral", (t, r) => Oe3(t) && !t.computed && t.key.type === "Identifier" && t.key.name === "template" && r === "value", ...fs15);
 }
 function Ds2(e, t) {
   return T3(e, x2.Block | x2.Leading, ({ value: r }) => r === ` ${t} `);
@@ -39692,7 +40034,7 @@ var ft4 = w4((gx, Mi3) => {
   ct4.default = ct4;
 });
 var fe3 = w4((wx, zi3) => {
-  var Bi3 = Me4(), Ui3 = ft4(), Fc2 = ut4(), { isClean: Fi3, my: $i3 } = Ht4(), fs20, Wi3, Gi3, ps3;
+  var Bi3 = Me4(), Ui3 = ft4(), Fc2 = ut4(), { isClean: Fi3, my: $i3 } = Ht4(), fs16, Wi3, Gi3, ps3;
   function Yi3(t) {
     return t.map((e) => (e.nodes && (e.nodes = Yi3(e.nodes)), delete e.source, e));
   }
@@ -39791,7 +40133,7 @@ var fe3 = w4((wx, zi3) => {
       } else if (e.selector || e.selectors)
         e = [new ps3(e)];
       else if (e.name)
-        e = [new fs20(e)];
+        e = [new fs16(e)];
       else if (e.text)
         e = [new Bi3(e)];
       else
@@ -39893,7 +40235,7 @@ var fe3 = w4((wx, zi3) => {
     ps3 = t;
   };
   z3.registerAtRule = (t) => {
-    fs20 = t;
+    fs16 = t;
   };
   z3.registerRoot = (t) => {
     Gi3 = t;
@@ -39901,7 +40243,7 @@ var fe3 = w4((wx, zi3) => {
   zi3.exports = z3;
   z3.default = z3;
   z3.rebuild = (t) => {
-    t.type === "atrule" ? Object.setPrototypeOf(t, fs20.prototype) : t.type === "rule" ? Object.setPrototypeOf(t, ps3.prototype) : t.type === "decl" ? Object.setPrototypeOf(t, Ui3.prototype) : t.type === "comment" ? Object.setPrototypeOf(t, Bi3.prototype) : t.type === "root" && Object.setPrototypeOf(t, Gi3.prototype), t[$i3] = true, t.nodes && t.nodes.forEach((e) => {
+    t.type === "atrule" ? Object.setPrototypeOf(t, fs16.prototype) : t.type === "rule" ? Object.setPrototypeOf(t, ps3.prototype) : t.type === "decl" ? Object.setPrototypeOf(t, Ui3.prototype) : t.type === "comment" ? Object.setPrototypeOf(t, Bi3.prototype) : t.type === "root" && Object.setPrototypeOf(t, Gi3.prototype), t[$i3] = true, t.nodes && t.nodes.forEach((e) => {
       z3.rebuild(e);
     });
   };
@@ -45252,30 +45594,9 @@ var writeCodeGrepWarnings = (skippedResources, output) => {
   }
   output.writeWarn(warning);
 };
-var writeErrorResponse2 = (response, output) => {
-  if (output.json) {
-    output.writeJson(response);
-  } else {
-    output.writeWarn(`Error: ${response.error.message}`);
-  }
-  process.exitCode = 1;
-};
 var requestCodeResponse = async (id, output, input) => {
-  const result = await requestWatcherJson({
-    ...input,
-    id,
-    timeoutMs: 30000,
-    returnErrorResponse: true
-  });
-  if (!result.ok) {
-    writeRequestError(result, output);
-    return null;
-  }
-  if (!result.data.ok) {
-    writeErrorResponse2(result.data, output);
-    return null;
-  }
-  return result.data;
+  const result = await requestWatcherCommandAction({ ...input, id, timeoutMs: 30000 }, output);
+  return result?.data ?? null;
 };
 
 // dist/commands/codeEdit.js
@@ -45292,7 +45613,7 @@ var runCodeEdit = async (id, url, options) => {
   if (source === null) {
     return;
   }
-  const result = await requestWatcherAction({
+  const result = await requestWatcherCommandAction({
     id,
     path: "/code/edit",
     method: "POST",
@@ -45327,9 +45648,9 @@ async function resolveEditSource(id, url, options, output) {
   }
   return readStdinSource(output);
 }
-async function readFileSource(path14, output) {
+async function readFileSource(path15, output) {
   try {
-    return { text: await readFile6(path14, "utf8") };
+    return { text: await readFile6(path15, "utf8") };
   } catch (error) {
     output.writeWarn(`Failed to read file: ${error instanceof Error ? error.message : error}`);
     process.exitCode = 1;
@@ -45403,7 +45724,7 @@ async function loadFullSource(id, url, output) {
   const chunks = [];
   let offset = 0;
   for (;; ) {
-    const result = await requestWatcherAction({
+    const result = await requestWatcherCommandAction({
       id,
       path: "/code/read",
       method: "POST",
@@ -45538,7 +45859,7 @@ var runLocateLabel = async (id, label, options) => {
     exact: options.exact
   }, options);
 };
-var runLocateRequest = async (id, path14, body, options) => {
+var runLocateRequest = async (id, path15, body, options) => {
   const output = createOutput(options);
   const action = normalizeLocateAction(options.action, output);
   if (action == null && options.action) {
@@ -45554,9 +45875,9 @@ var runLocateRequest = async (id, path14, body, options) => {
     process.exitCode = 2;
     return;
   }
-  const result = await requestWatcherAction({
+  const result = await requestWatcherCommandAction({
     id,
-    path: path14,
+    path: path15,
     method: "POST",
     body,
     timeoutMs: 30000
@@ -45643,44 +45964,60 @@ Examples:
   });
 }
 
-// dist/cli/register/index.js
-var registerDefinedCommands = (program2) => {
-  defineCommands(program2, [domClickCommandDefinition]);
-};
-var coreProgramRegistrars = [
-  registerQuickAccess,
-  registerChrome,
-  registerWatcher,
-  registerPage,
-  registerDialog,
-  registerLogs,
-  registerNet,
-  registerAuth,
-  registerEval,
-  registerLocate,
-  registerCode,
-  registerDom,
-  registerDefinedCommands,
-  registerKeydown,
-  registerFill,
-  registerHover,
-  registerScrollTo,
-  registerStorage,
-  registerThrottle,
-  registerSnapshot,
-  registerTrace,
-  registerConfig,
-  registerExtension
-];
-
 // dist/cli/plugins/registerPlugins.js
-import path14 from "node:path";
+import path15 from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // ../argus-plugin-api/dist/index.js
 var ARGUS_PLUGIN_API_VERSION = 1;
 
+// dist/cli/plugins/pluginAliases.js
+var BUILTIN_PLUGIN_ALIASES = {
+  gsheets: "@vforsh/argus-plugin-google-sheets",
+  gs: "@vforsh/argus-plugin-google-sheets"
+};
+var resolvePluginAlias = (spec, aliases) => {
+  const trimmed = spec.trim();
+  const resolved = aliases[trimmed];
+  return resolved ? { spec: resolved, alias: trimmed } : { spec: trimmed, alias: null };
+};
+
+// dist/cli/plugins/pluginHost.js
+var DEFAULT_TIMEOUT_MS2 = 30000;
+var postWatcherJson = (id, path15, body, timeoutMs = DEFAULT_TIMEOUT_MS2) => requestWatcherJson({
+  id,
+  path: path15,
+  method: "POST",
+  body,
+  timeoutMs
+});
+var argus = {
+  eval: (id, request, options) => postWatcherJson(id, "/eval", request, options?.timeoutMs ?? request.timeoutMs ?? DEFAULT_TIMEOUT_MS2),
+  dom: {
+    click: (id, request, options) => postWatcherJson(id, "/dom/click", request, options?.timeoutMs),
+    info: (id, request, options) => postWatcherJson(id, "/dom/info", request, options?.timeoutMs),
+    keydown: (id, request, options) => postWatcherJson(id, "/dom/keydown", request, options?.timeoutMs)
+  },
+  screenshot: (id, request = {}, options) => postWatcherJson(id, "/screenshot", request, options?.timeoutMs)
+};
+var createPluginHost = () => ({
+  createOutput,
+  requestWatcherJson,
+  writeRequestError,
+  runChromeOpen,
+  defineWatcherCommand,
+  argus
+});
+
 // dist/cli/plugins/registerPlugins.js
+var lastPluginLoadReport = {
+  configPath: null,
+  configDir: null,
+  cwd: process.cwd(),
+  entries: []
+};
+var getPluginLoadReport = () => lastPluginLoadReport;
 var parseEnvPlugins = () => {
   const raw = process.env.ARGUS_PLUGINS;
   if (!raw)
@@ -45688,6 +46025,30 @@ var parseEnvPlugins = () => {
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
 };
 var uniq = (values) => Array.from(new Set(values));
+var createPluginInput = (source, spec, aliases) => {
+  const resolved = resolvePluginAlias(spec, aliases);
+  return { source, spec, resolvedSpec: resolved.spec, alias: resolved.alias };
+};
+var parseCliPlugins = (argv) => {
+  const plugins = [];
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--plugin") {
+      const value = argv[i + 1];
+      if (value && !value.startsWith("-")) {
+        plugins.push(value);
+        i++;
+      }
+      continue;
+    }
+    if (arg.startsWith("--plugin=")) {
+      const value = arg.slice("--plugin=".length).trim();
+      if (value)
+        plugins.push(value);
+    }
+  }
+  return plugins;
+};
 var resolveWithImportMeta = (specifier, parentUrl) => {
   const resolver2 = import.meta.resolve;
   if (typeof resolver2 !== "function") {
@@ -45695,6 +46056,7 @@ var resolveWithImportMeta = (specifier, parentUrl) => {
   }
   return resolver2(specifier, parentUrl);
 };
+var isPathLikeSpecifier = (specifier) => specifier.startsWith(".") || specifier.startsWith("/");
 var resolvePluginModuleUrl = (specifier, baseDirs) => {
   const trimmed = specifier.trim();
   if (!trimmed) {
@@ -45704,6 +46066,23 @@ var resolvePluginModuleUrl = (specifier, baseDirs) => {
     return { ok: true, url: trimmed };
   }
   const errors = [];
+  if (isPathLikeSpecifier(trimmed)) {
+    for (const baseDir of baseDirs) {
+      try {
+        const resolvedPath = path15.resolve(baseDir, trimmed);
+        if (existsSync3(resolvedPath)) {
+          return { ok: true, url: pathToFileURL2(resolvedPath).href };
+        }
+        errors.push(`${baseDir}: ${resolvedPath} does not exist`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        errors.push(`${baseDir}: ${msg}`);
+      }
+    }
+    return { ok: false, error: `Failed to resolve plugin path "${specifier}". Tried:
+${errors.map((e) => `- ${e}`).join(`
+`)}` };
+  }
   try {
     return { ok: true, url: resolveWithImportMeta(trimmed, import.meta.url) };
   } catch (error) {
@@ -45712,7 +46091,7 @@ var resolvePluginModuleUrl = (specifier, baseDirs) => {
   }
   for (const baseDir of baseDirs) {
     try {
-      const baseUrl = pathToFileURL2(path14.join(baseDir, "noop.js")).href;
+      const baseUrl = pathToFileURL2(path15.join(baseDir, "noop.js")).href;
       return { ok: true, url: resolveWithImportMeta(trimmed, baseUrl) };
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -45739,26 +46118,62 @@ var extractPlugin = (mod) => {
     return null;
   return plugin;
 };
+var normalizeOptionalString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var normalizeCommands = (value) => {
+  if (!Array.isArray(value))
+    return [];
+  const commands = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+  return Array.from(new Set(commands));
+};
 var warnPluginLoad = (source, spec, message) => {
   const output = createOutput({ json: false });
   output.writeWarn(`[plugins] Failed to load (${source}) "${spec}": ${message}`);
 };
-var registerPlugins = async (program2) => {
+var recordPluginFailure = (entries, entry, error, url) => {
+  entries.push({ source: entry.source, spec: entry.spec, resolvedSpec: entry.resolvedSpec, alias: entry.alias, status: "failed", url, error });
+  warnPluginLoad(entry.source, entry.spec, error);
+};
+var createLoadedEntry = (entry, plugin, url) => ({
+  source: entry.source,
+  spec: entry.spec,
+  resolvedSpec: entry.resolvedSpec,
+  alias: entry.alias,
+  status: "loaded",
+  name: plugin.name,
+  version: normalizeOptionalString(plugin.version),
+  description: normalizeOptionalString(plugin.description),
+  commands: normalizeCommands(plugin.commands),
+  homepage: normalizeOptionalString(plugin.homepage),
+  minArgusVersion: normalizeOptionalString(plugin.minArgusVersion),
+  url
+});
+var registerPlugins = async (program2, argv = process.argv.slice(2)) => {
   const cwd = process.cwd();
   const configPath = resolveArgusConfigPath({ cwd });
   const configResult = configPath ? loadArgusConfig(configPath) : null;
+  const aliases = { ...BUILTIN_PLUGIN_ALIASES, ...configResult?.config.pluginAliases ?? {} };
   const configPlugins = configResult?.config.plugins ?? [];
   const envPlugins = parseEnvPlugins();
+  const cliPlugins = parseCliPlugins(argv);
   const all = [];
   for (const spec of configPlugins)
-    all.push({ source: "config", spec });
+    all.push(createPluginInput("config", spec, aliases));
   for (const spec of envPlugins)
-    all.push({ source: "env", spec });
+    all.push(createPluginInput("env", spec, aliases));
+  for (const spec of cliPlugins)
+    all.push(createPluginInput("cli", spec, aliases));
+  const entries = [];
+  lastPluginLoadReport = {
+    configPath,
+    configDir: configResult?.configDir ?? null,
+    cwd,
+    entries
+  };
   if (all.length === 0)
     return;
   const seen = new Set;
   const ordered = all.filter((p2) => {
-    const key = p2.spec.trim();
+    const key = p2.resolvedSpec.trim();
     if (!key)
       return false;
     if (seen.has(key))
@@ -45769,37 +46184,312 @@ var registerPlugins = async (program2) => {
   const baseDirs = uniq([configResult?.configDir, cwd].filter((v4) => Boolean(v4)));
   const ctxBase = {
     apiVersion: ARGUS_PLUGIN_API_VERSION,
-    host: { createOutput, requestWatcherJson, writeRequestError, runChromeOpen },
+    host: createPluginHost(),
     cwd,
     configPath,
     configDir: configResult?.configDir ?? null
   };
   for (const entry of ordered) {
-    const resolved = resolvePluginModuleUrl(entry.spec, baseDirs);
+    const resolved = resolvePluginModuleUrl(entry.resolvedSpec, baseDirs);
     if (!resolved.ok) {
-      warnPluginLoad(entry.source, entry.spec, resolved.error);
+      recordPluginFailure(entries, entry, resolved.error);
       continue;
     }
     let mod;
     try {
       mod = await import(resolved.url);
     } catch (error) {
-      warnPluginLoad(entry.source, entry.spec, error instanceof Error ? error.message : String(error));
+      recordPluginFailure(entries, entry, error instanceof Error ? error.message : String(error), resolved.url);
       continue;
     }
     const plugin = extractPlugin(mod);
     if (!plugin) {
-      warnPluginLoad(entry.source, entry.spec, "Invalid plugin export (expected default export with { apiVersion: 1, name, register() }).");
+      recordPluginFailure(entries, entry, "Invalid plugin export (expected default export with { apiVersion: 1, name, register() }).", resolved.url);
       continue;
     }
     try {
       await plugin.register({ ...ctxBase, program: program2 });
+      entries.push(createLoadedEntry(entry, plugin, resolved.url));
     } catch (error) {
-      warnPluginLoad(entry.source, entry.spec, error instanceof Error ? error.message : String(error));
+      recordPluginFailure(entries, entry, error instanceof Error ? error.message : String(error), resolved.url);
     }
   }
 };
 
+// dist/commands/pluginList.js
+var runPluginList = (options) => {
+  const output = createOutput(options);
+  const report = getPluginLoadReport();
+  if (options.json) {
+    output.writeJson(report);
+    return;
+  }
+  if (report.entries.length === 0) {
+    output.writeHuman("No plugins configured for this invocation.");
+    return;
+  }
+  for (const entry of report.entries) {
+    const spec = entry.alias ? `${entry.alias} -> ${entry.resolvedSpec}` : entry.spec;
+    if (entry.status === "failed") {
+      output.writeHuman(`${entry.source}	${spec}	failed	${entry.error}`);
+      continue;
+    }
+    const version2 = entry.version ? ` v${entry.version}` : "";
+    const commands = entry.commands.length > 0 ? ` commands: ${entry.commands.join(", ")}` : "";
+    const description = entry.description ? ` — ${entry.description}` : "";
+    output.writeHuman(`${entry.source}	${entry.name}${version2}	${spec}	loaded${commands}${description}`);
+  }
+};
+
+// dist/commands/pluginConfig.js
+import fs16 from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import path16 from "node:path";
+var DEFAULT_CONFIG_PATH2 = ".argus/config.json";
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var resolveTargetConfigPath = (cwd, cliPath) => {
+  if (cliPath) {
+    const resolved = path16.isAbsolute(cliPath) ? cliPath : path16.resolve(cwd, cliPath);
+    return { path: resolved, exists: existsSync4(resolved) };
+  }
+  const discovered = resolveArgusConfigPath({ cwd });
+  if (discovered)
+    return { path: discovered, exists: true };
+  if (process.exitCode)
+    return null;
+  return { path: path16.resolve(cwd, DEFAULT_CONFIG_PATH2), exists: false };
+};
+var readConfigObject = async (configPath, exists) => {
+  if (!exists)
+    return {};
+  let raw;
+  try {
+    raw = await fs16.readFile(configPath, "utf8");
+  } catch (error) {
+    console.error(`Failed to read Argus config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 2;
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (isRecord2(parsed))
+      return parsed;
+    console.error(`Invalid Argus config at ${configPath}: config root must be an object.`);
+    process.exitCode = 2;
+    return null;
+  } catch (error) {
+    console.error(`Invalid Argus config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 2;
+    return null;
+  }
+};
+var getPluginSpecs = (config, configPath) => {
+  const value = config.plugins;
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    console.error(`Invalid Argus config at ${configPath}: "plugins" must be an array of non-empty strings.`);
+    process.exitCode = 2;
+    return null;
+  }
+  return value;
+};
+var getPluginAliases = (config, configPath) => {
+  const value = config.pluginAliases;
+  if (value === undefined)
+    return {};
+  if (!isRecord2(value)) {
+    console.error(`Invalid Argus config at ${configPath}: "pluginAliases" must be an object with string values.`);
+    process.exitCode = 2;
+    return null;
+  }
+  const aliases = {};
+  for (const [alias, spec] of Object.entries(value)) {
+    if (alias.trim() === "" || typeof spec !== "string" || spec.trim() === "") {
+      console.error(`Invalid Argus config at ${configPath}: "pluginAliases" keys and values must be non-empty strings.`);
+      process.exitCode = 2;
+      return null;
+    }
+    aliases[alias] = spec;
+  }
+  return aliases;
+};
+var writeConfigObject = async (configPath, config) => {
+  try {
+    await fs16.mkdir(path16.dirname(configPath), { recursive: true });
+    await fs16.writeFile(configPath, `${JSON.stringify(config, null, "\t")}
+`, "utf8");
+    return true;
+  } catch (error) {
+    console.error(`Failed to write Argus config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 2;
+    return false;
+  }
+};
+var loadMutablePluginConfig = async (options) => {
+  const target = resolveTargetConfigPath(process.cwd(), options.path);
+  if (!target)
+    return null;
+  const config = await readConfigObject(target.path, target.exists);
+  if (!config)
+    return null;
+  const plugins = getPluginSpecs(config, target.path);
+  if (!plugins)
+    return null;
+  const pluginAliases = getPluginAliases(config, target.path);
+  if (!pluginAliases)
+    return null;
+  return { path: target.path, config, plugins, pluginAliases };
+};
+var parsePluginAddTarget = (raw, aliases) => {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  const separator = trimmed.indexOf("=");
+  if (separator < 0) {
+    const resolved = resolvePluginAlias(trimmed, aliases);
+    return { spec: trimmed, alias: resolved.alias, resolvedSpec: resolved.spec };
+  }
+  const alias = trimmed.slice(0, separator).trim();
+  const spec = trimmed.slice(separator + 1).trim();
+  return alias && spec ? { spec: alias, alias, resolvedSpec: spec } : null;
+};
+var runPluginAdd = async (targetSpec, options) => {
+  const output = createOutput(options);
+  const loaded = await loadMutablePluginConfig(options);
+  if (!loaded)
+    return;
+  const parsed = parsePluginAddTarget(targetSpec, { ...BUILTIN_PLUGIN_ALIASES, ...loaded.pluginAliases });
+  if (!parsed) {
+    output.writeWarn("Plugin specifier is required.");
+    process.exitCode = 2;
+    return;
+  }
+  const aliases = { ...BUILTIN_PLUGIN_ALIASES, ...loaded.pluginAliases };
+  const hasSameResolvedPlugin = loaded.plugins.some((spec) => resolvePluginAlias(spec, aliases).spec === parsed.resolvedSpec);
+  const changed = !loaded.plugins.includes(parsed.spec) && !hasSameResolvedPlugin;
+  const aliasChanged = parsed.alias !== null && loaded.pluginAliases[parsed.alias] !== parsed.resolvedSpec;
+  if (changed) {
+    loaded.plugins = [...loaded.plugins, parsed.spec];
+    loaded.config.plugins = loaded.plugins;
+  }
+  if (aliasChanged && parsed.alias) {
+    loaded.pluginAliases[parsed.alias] = parsed.resolvedSpec;
+    loaded.config.pluginAliases = loaded.pluginAliases;
+  }
+  if ((changed || aliasChanged) && !await writeConfigObject(loaded.path, loaded.config))
+    return;
+  const response = {
+    configPath: loaded.path,
+    spec: parsed.spec,
+    alias: parsed.alias,
+    resolvedSpec: parsed.resolvedSpec,
+    changed: changed || aliasChanged,
+    plugins: loaded.plugins,
+    pluginAliases: loaded.pluginAliases
+  };
+  if (options.json)
+    output.writeJson(response);
+  else
+    output.writeHuman(response.changed ? `Added plugin ${parsed.spec} to ${loaded.path}` : `Plugin already configured: ${parsed.spec}`);
+};
+var runPluginRemove = async (targetSpec, options) => {
+  const output = createOutput(options);
+  const normalized = targetSpec.trim();
+  if (!normalized) {
+    output.writeWarn("Plugin specifier or name is required.");
+    process.exitCode = 2;
+    return;
+  }
+  const loaded = await loadMutablePluginConfig(options);
+  if (!loaded)
+    return;
+  const aliases = { ...BUILTIN_PLUGIN_ALIASES, ...loaded.pluginAliases };
+  const next = loaded.plugins.filter((spec) => !matchesPluginSpecifier(spec, normalized, aliases));
+  const nextAliases = Object.fromEntries(Object.entries(loaded.pluginAliases).filter(([alias, spec]) => !matchesPluginAlias(alias, spec, normalized)));
+  const changed = next.length !== loaded.plugins.length;
+  const aliasChanged = Object.keys(nextAliases).length !== Object.keys(loaded.pluginAliases).length;
+  if (changed || aliasChanged) {
+    loaded.config.plugins = next;
+    loaded.config.pluginAliases = Object.keys(nextAliases).length > 0 ? nextAliases : undefined;
+    if (!await writeConfigObject(loaded.path, loaded.config))
+      return;
+  }
+  const response = { configPath: loaded.path, target: normalized, changed: changed || aliasChanged, plugins: next, pluginAliases: nextAliases };
+  if (options.json)
+    output.writeJson(response);
+  else
+    output.writeHuman(response.changed ? `Removed plugin ${normalized} from ${loaded.path}` : `Plugin not configured: ${normalized}`);
+};
+var matchesPluginSpecifier = (spec, target, aliases) => {
+  const resolved = resolvePluginAlias(spec, aliases);
+  return spec === target || resolved.spec === target || resolved.alias === target || pluginKey(spec) === pluginKey(target) || pluginKey(resolved.spec) === pluginKey(target);
+};
+var matchesPluginAlias = (alias, spec, target) => alias === target || spec === target || pluginKey(alias) === pluginKey(target) || pluginKey(spec) === pluginKey(target);
+var pluginKey = (value) => {
+  const withoutPath = value.replace(/\\/g, "/").split("/").filter(Boolean).pop() ?? value;
+  const withoutExt = withoutPath.replace(/\.(mjs|js|ts)$/, "");
+  return withoutExt.replace(/^argus-plugin-/, "").replace(/^@[^/]+\/argus-plugin-/, "");
+};
+
+// dist/cli/register/registerPlugin.js
+function registerPlugin(program2) {
+  const plugin = program2.command("plugin").alias("plugins").description("Manage Argus CLI plugins");
+  plugin.command("list").alias("ls").description("List plugins discovered for this invocation").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus plugin list
+  $ argus --plugin ./plugins/foo.js plugin list --json
+`).action((options) => {
+    runPluginList(options);
+  });
+  plugin.command("add <specifier>").description("Add a plugin specifier or alias to the Argus config").option("--path <file>", "Config file to update (default: discovered config or .argus/config.json)").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus plugin add gsheets
+  $ argus plugin add gs=@vforsh/argus-plugin-google-sheets
+  $ argus plugin add ./plugins/foo.js
+`).action(async (specifier, options) => {
+    await runPluginAdd(specifier, options);
+  });
+  plugin.command("remove <specifierOrName>").alias("rm").description("Remove a plugin from the Argus config").option("--path <file>", "Config file to update (default: discovered config or .argus/config.json)").option("--json", "Output JSON for automation").addHelpText("after", `
+Examples:
+  $ argus plugin remove @vforsh/argus-plugin-google-sheets
+  $ argus plugin remove google-sheets
+`).action(async (specifierOrName, options) => {
+    await runPluginRemove(specifierOrName, options);
+  });
+}
+
+// dist/cli/register/index.js
+var registerDefinedCommands = (program2) => {
+  defineCommands(program2, [domClickCommandDefinition]);
+};
+var coreProgramRegistrars = [
+  registerQuickAccess,
+  registerChrome,
+  registerWatcher,
+  registerPage,
+  registerDialog,
+  registerLogs,
+  registerNet,
+  registerAuth,
+  registerEval,
+  registerLocate,
+  registerCode,
+  registerDom,
+  registerDefinedCommands,
+  registerKeydown,
+  registerFill,
+  registerHover,
+  registerScrollTo,
+  registerStorage,
+  registerThrottle,
+  registerSnapshot,
+  registerTrace,
+  registerConfig,
+  registerPlugin,
+  registerExtension
+];
+
 // dist/bin.js
 var program2 = createProgram();
 for (const registerProgramPart of coreProgramRegistrars) {