@vforsh/argus 0.1.14 → 0.1.15

package/dist/argus.js

@@ -5,15 +5,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -2130,7 +2144,7 @@ var {
 // package.json
 var package_default = {
   name: "@vforsh/argus",
-  version: "0.1.14",
+  version: "0.1.15",
   repository: {
     type: "git",
     url: "git+https://github.com/vforsh/argus.git",
@@ -2172,7 +2186,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 +2197,7 @@ function createProgram() {
   });
   return program2;
 }
+var collectPluginOption = (value, previous) => [...previous, value];
 
 // ../argus-core/dist/protocol/logs.js
 var formatLogLevelTag = (level) => {
@@ -3311,11 +3326,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 +4392,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 +6446,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 +7366,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 +7883,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 +8795,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 +9444,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 +9522,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 +9660,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) => {
@@ -15207,13 +15211,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);
   }
@@ -16085,7 +16091,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 +16165,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 +16315,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 +16345,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 +16804,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) => {
@@ -17361,16 +17386,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 +17425,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 +17462,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 +17873,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,23 +18010,12 @@ 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";
@@ -18256,6 +18195,31 @@ var resolveDerivedNetFilters = (options) => {
 
 // dist/commands/evalShared.js
 import { readFile as readFile2 } from "node:fs/promises";
+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 !== "-";
@@ -18272,6 +18236,7 @@ var resolveExpression = async (inline, options, output) => {
     output.writeWarn("Cannot combine --file with stdin input");
     return null;
   }
+  let expression;
   if (hasFile) {
     try {
       const content = await readFile2(options.file ?? "", "utf8");
@@ -18279,34 +18244,51 @@ var resolveExpression = async (inline, options, output) => {
         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 = "";
@@ -19380,32 +19362,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 +19695,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 +19814,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 +19832,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,16 +20120,14 @@ 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) => {
@@ -20380,116 +20356,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 +20535,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 +20642,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 +20658,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 +20727,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 +20762,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 (pollResult.kind === "exhausted") {
+    output.writeWarn(`Exhausted after ${pollResult.iterations} iterations without a truthy result`);
+    process.exitCode = 1;
+    return;
   }
-  if (interrupted) {
+  if (pollResult.kind === "condition-error") {
+    output.writeWarn(pollResult.error);
+    process.exitCode = 1;
+    return;
+  }
+  if (pollResult.kind === "interrupted") {
     process.exitCode = 130;
   }
 };
@@ -20911,11 +20894,12 @@ ${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("--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 "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
@@ -20940,6 +20924,7 @@ Examples:
       until: options.until,
       file: options.file,
       stdin: options.stdin,
+      inject: options.inject,
       iframe: options.iframe,
       iframeNamespace: options.iframeNamespace,
       iframeTimeout: options.iframeTimeout,
@@ -20955,7 +20940,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("--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 +20949,7 @@ 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 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, {
@@ -20980,6 +20966,7 @@ Examples:
       verbose: options.verbose,
       file: options.file,
       stdin: options.stdin,
+      inject: options.inject,
       iframe: options.iframe,
       iframeNamespace: options.iframeNamespace,
       iframeTimeout: options.iframeTimeout,
@@ -21072,26 +21059,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 +21098,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 +21136,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 +21169,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 +21237,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 +21566,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 +21596,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 +21613,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 +21627,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 +21660,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 +21669,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 +21687,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 +21701,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 +22109,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 +22471,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 +22497,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();
@@ -22850,6 +22785,7 @@ var DEFAULT_CONFIG_PATH = ".argus/config.json";
 var buildConfigTemplate = (schemaRef) => ({
   $schema: schemaRef,
   plugins: [],
+  pluginAliases: {},
   chrome: {
     start: {
       url: "http://localhost:3000",
@@ -45252,30 +45188,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 +45207,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",
@@ -45403,7 +45318,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",
@@ -45554,7 +45469,7 @@ var runLocateRequest = async (id, path14, body, options) => {
     process.exitCode = 2;
     return;
   }
-  const result = await requestWatcherAction({
+  const result = await requestWatcherCommandAction({
     id,
     path: path14,
     method: "POST",
@@ -45643,44 +45558,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 { 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, path14, body, timeoutMs = DEFAULT_TIMEOUT_MS2) => requestWatcherJson({
+  id,
+  path: path14,
+  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 +45619,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 +45650,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 +45660,23 @@ var resolvePluginModuleUrl = (specifier, baseDirs) => {
     return { ok: true, url: trimmed };
   }
   const errors = [];
+  if (isPathLikeSpecifier(trimmed)) {
+    for (const baseDir of baseDirs) {
+      try {
+        const resolvedPath = path14.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) {
@@ -45739,26 +45712,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,36 +45778,311 @@ 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 fs20 from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import path15 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 = path15.isAbsolute(cliPath) ? cliPath : path15.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: path15.resolve(cwd, DEFAULT_CONFIG_PATH2), exists: false };
+};
+var readConfigObject = async (configPath, exists) => {
+  if (!exists)
+    return {};
+  let raw;
+  try {
+    raw = await fs20.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 fs20.mkdir(path15.dirname(configPath), { recursive: true });
+    await fs20.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();