chrome-relay 0.5.11 → 0.5.13

package/dist/cli.js

@@ -9,6 +9,714 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../protocol/dist/args/shared.js
+function asObject(input, tool) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${tool}: arguments must be a JSON object.`,
+      tool,
+      phase: "parse_arguments",
+      details: { received: input },
+      retryable: false
+    });
+  }
+  return input;
+}
+function requireString(obj, key, tool) {
+  const v = obj[key];
+  if (typeof v !== "string" || !v) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${tool}: \`${key}\` is required and must be a non-empty string.`,
+      tool,
+      phase: "parse_arguments",
+      details: { field: key, received: v },
+      retryable: false
+    });
+  }
+  return v;
+}
+function optString(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" && v ? v : void 0;
+}
+function optNumber(obj, key) {
+  const v = obj[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function optBool(obj, key) {
+  const v = obj[key];
+  return typeof v === "boolean" ? v : void 0;
+}
+function parseTargetArgs(obj) {
+  const out = {};
+  if (typeof obj.tabId === "number")
+    out.tabId = obj.tabId;
+  if (typeof obj.workspaceName === "string" && obj.workspaceName)
+    out.workspaceName = obj.workspaceName;
+  if (typeof obj.groupName === "string" && obj.groupName)
+    out.groupName = obj.groupName;
+  return out;
+}
+var init_shared = __esm({
+  "../protocol/dist/args/shared.js"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// ../protocol/dist/args/navigate.js
+function parseChromeNavigateArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.NAVIGATE);
+  const out = {
+    url: requireString(obj, "url", TOOL_NAMES.NAVIGATE),
+    ...parseTargetArgs(obj)
+  };
+  if (typeof obj.tabId === "string" && obj.tabId) {
+    const n = Number(obj.tabId);
+    if (!Number.isFinite(n)) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `chrome_navigate: invalid tabId ${JSON.stringify(obj.tabId)}. Expected a number.`,
+        tool: TOOL_NAMES.NAVIGATE,
+        phase: "parse_arguments",
+        details: { field: "tabId", received: obj.tabId },
+        retryable: false
+      });
+    }
+    out.tabId = n;
+  } else {
+    const n = optNumber(obj, "tabId");
+    if (n !== void 0)
+      out.tabId = n;
+  }
+  const newTab = optBool(obj, "newTab");
+  if (newTab !== void 0)
+    out.newTab = newTab;
+  const active = optBool(obj, "active");
+  if (active !== void 0)
+    out.active = active;
+  const allowPartial = optBool(obj, "allowPartial");
+  if (allowPartial !== void 0)
+    out.allowPartial = allowPartial;
+  void optString;
+  return out;
+}
+var init_navigate = __esm({
+  "../protocol/dist/args/navigate.js"() {
+    "use strict";
+    init_dist();
+    init_shared();
+  }
+});
+
+// ../protocol/dist/args/hover.js
+function parseChromeHoverArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.HOVER);
+  const target = parseTargetArgs(obj);
+  const x = optNumber(obj, "x");
+  const y = optNumber(obj, "y");
+  if (x !== void 0 && y !== void 0) {
+    return { ...target, kind: "coords", x, y };
+  }
+  const selector = optString(obj, "selector");
+  if (selector) {
+    return { ...target, kind: "selector", selector };
+  }
+  throw new RelayError({
+    code: "invalid_arguments",
+    message: "chrome_hover requires either a selector or x AND y.",
+    tool: TOOL_NAMES.HOVER,
+    phase: "parse_arguments",
+    details: { received: { selector: obj.selector, x: obj.x, y: obj.y } },
+    retryable: false
+  });
+}
+var init_hover = __esm({
+  "../protocol/dist/args/hover.js"() {
+    "use strict";
+    init_dist();
+    init_shared();
+  }
+});
+
+// ../protocol/dist/args/network.js
+function parseFilter(obj) {
+  const out = {};
+  const filter = optString(obj, "filter");
+  if (filter)
+    out.filter = filter;
+  const method = optString(obj, "method");
+  if (method)
+    out.method = method;
+  const limit = optNumber(obj, "limit");
+  if (limit !== void 0)
+    out.limit = limit;
+  const status = obj.status;
+  if (status !== void 0 && status !== null) {
+    if (typeof status !== "string" || !VALID_STATUSES.includes(status)) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `chrome_network: invalid status ${JSON.stringify(status)}. Expected one of: ${VALID_STATUSES.join(", ")}.`,
+        tool: TOOL_NAMES.NETWORK,
+        phase: "parse_status",
+        details: { received: status, validChoices: VALID_STATUSES },
+        retryable: false
+      });
+    }
+    out.status = status;
+  }
+  return out;
+}
+function parseChromeNetworkArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.NETWORK);
+  const target = parseTargetArgs(obj);
+  const rawAction = obj.action;
+  const action = typeof rawAction === "string" ? rawAction : "read";
+  if (action === "clear") {
+    return { ...target, action: "clear" };
+  }
+  if (action === "body") {
+    const requestId = optString(obj, "requestId");
+    if (!requestId) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: "chrome_network body requires `requestId` (a non-empty string).",
+        tool: TOOL_NAMES.NETWORK,
+        phase: "parse_arguments",
+        details: { field: "requestId", received: obj.requestId },
+        retryable: false
+      });
+    }
+    const out = {
+      ...target,
+      action: "body",
+      requestId
+    };
+    const full = optBool(obj, "full");
+    if (full !== void 0)
+      out.full = full;
+    const head = optNumber(obj, "head");
+    if (head !== void 0)
+      out.head = head;
+    return out;
+  }
+  if (action === "har") {
+    const withBodies = optBool(obj, "withBodies");
+    const bestEffortBodies = optBool(obj, "bestEffortBodies");
+    return {
+      ...target,
+      action: "har",
+      ...withBodies !== void 0 ? { withBodies } : {},
+      ...bestEffortBodies !== void 0 ? { bestEffortBodies } : {},
+      ...parseFilter(obj)
+    };
+  }
+  if (action === "read") {
+    return { ...target, action: "read", ...parseFilter(obj) };
+  }
+  throw new RelayError({
+    code: "invalid_arguments",
+    message: `chrome_network: unknown action "${action}". Expected read | clear | har | body.`,
+    tool: TOOL_NAMES.NETWORK,
+    phase: "parse_action",
+    details: { received: action, validChoices: ["read", "clear", "har", "body"] },
+    retryable: false
+  });
+}
+var VALID_STATUSES;
+var init_network = __esm({
+  "../protocol/dist/args/network.js"() {
+    "use strict";
+    init_dist();
+    init_shared();
+    VALID_STATUSES = ["ok", "redirect", "client_error", "server_error", "failed"];
+  }
+});
+
+// ../protocol/dist/args/simple.js
+function parseGetWindowsAndTabsArgs(_input) {
+  return {};
+}
+function parseChromeSelfReloadArgs(_input) {
+  return {};
+}
+function parseChromeReadPageArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.READ_PAGE);
+  const out = { ...parseTargetArgs(obj) };
+  const io = optBool(obj, "interactiveOnly");
+  if (io !== void 0)
+    out.interactiveOnly = io;
+  return out;
+}
+function parseChromeClickArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.CLICK);
+  return {
+    selector: requireString(obj, "selector", TOOL_NAMES.CLICK),
+    ...parseTargetArgs(obj)
+  };
+}
+function parseChromeFillArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.FILL);
+  if (typeof obj.value !== "string") {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.FILL}: \`value\` is required and must be a string (empty string allowed).`,
+      tool: TOOL_NAMES.FILL,
+      phase: "parse_arguments",
+      details: { field: "value", received: obj.value },
+      retryable: false
+    });
+  }
+  return {
+    selector: requireString(obj, "selector", TOOL_NAMES.FILL),
+    value: obj.value,
+    ...parseTargetArgs(obj)
+  };
+}
+function parseChromeKeyboardArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.KEYBOARD);
+  return {
+    keys: requireString(obj, "keys", TOOL_NAMES.KEYBOARD),
+    ...parseTargetArgs(obj)
+  };
+}
+function parseChromeTypeArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.TYPE);
+  const out = {
+    text: requireString(obj, "text", TOOL_NAMES.TYPE),
+    ...parseTargetArgs(obj)
+  };
+  const selector = optString(obj, "selector");
+  if (selector)
+    out.selector = selector;
+  return out;
+}
+function parseChromeEvaluateArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.EVALUATE);
+  const out = {
+    code: requireString(obj, "code", TOOL_NAMES.EVALUATE),
+    ...parseTargetArgs(obj)
+  };
+  const t = optNumber(obj, "timeoutMs");
+  if (t !== void 0)
+    out.timeoutMs = t;
+  return out;
+}
+function parseChromeSwitchTabArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.SWITCH_TAB);
+  const tabId = Number(obj.tabId);
+  if (!Number.isFinite(tabId)) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.SWITCH_TAB} requires a numeric tabId.`,
+      tool: TOOL_NAMES.SWITCH_TAB,
+      phase: "parse_arguments",
+      details: { received: obj.tabId },
+      retryable: false
+    });
+  }
+  return { tabId };
+}
+function parseChromeCloseTabsArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.CLOSE_TABS);
+  if (!Array.isArray(obj.tabIds)) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.CLOSE_TABS} requires a numeric tabIds array.`,
+      tool: TOOL_NAMES.CLOSE_TABS,
+      phase: "parse_arguments",
+      details: { field: "tabIds", received: obj.tabIds },
+      retryable: false
+    });
+  }
+  const tabIds = obj.tabIds.map((v) => Number(v));
+  if (tabIds.length === 0 || tabIds.some((n) => !Number.isFinite(n))) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.CLOSE_TABS} requires a non-empty array of numeric tab IDs.`,
+      tool: TOOL_NAMES.CLOSE_TABS,
+      phase: "parse_arguments",
+      details: { received: obj.tabIds },
+      retryable: false
+    });
+  }
+  return { tabIds };
+}
+function parseChromeAxArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.AX);
+  const out = { ...parseTargetArgs(obj) };
+  const io = optBool(obj, "interactiveOnly");
+  if (io !== void 0)
+    out.interactiveOnly = io;
+  const root = optString(obj, "rootRole");
+  if (root)
+    out.rootRole = root;
+  const is = optBool(obj, "includeSubframes");
+  if (is !== void 0)
+    out.includeSubframes = is;
+  return out;
+}
+function parseChromeClickAxArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.CLICK_AX);
+  const node = Number(obj.node ?? obj.id);
+  if (!Number.isFinite(node) || node <= 0) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.CLICK_AX} requires \`node\` (a positive backendDOMNodeId from chrome_ax).`,
+      tool: TOOL_NAMES.CLICK_AX,
+      phase: "parse_arguments",
+      details: { received: obj.node ?? obj.id },
+      retryable: false
+    });
+  }
+  return { node, ...parseTargetArgs(obj) };
+}
+function parseChromeScreenshotArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.SCREENSHOT);
+  const out = { ...parseTargetArgs(obj) };
+  const fp = optBool(obj, "fullPage");
+  if (fp !== void 0)
+    out.fullPage = fp;
+  const bbox = optString(obj, "bbox");
+  if (bbox)
+    out.bbox = bbox;
+  const sel = optString(obj, "selector");
+  if (sel)
+    out.selector = sel;
+  const pad = optNumber(obj, "padding");
+  if (pad !== void 0)
+    out.padding = pad;
+  const me = optNumber(obj, "maxEdge");
+  if (me !== void 0 && me > 0)
+    out.maxEdge = me;
+  return out;
+}
+var init_simple = __esm({
+  "../protocol/dist/args/simple.js"() {
+    "use strict";
+    init_dist();
+    init_shared();
+  }
+});
+
+// ../protocol/dist/args/multi.js
+function invalidAction(tool, received, expected) {
+  throw new RelayError({
+    code: "invalid_arguments",
+    message: `${tool}: unknown action ${JSON.stringify(received)}. Expected ${expected.join(" | ")}.`,
+    tool,
+    phase: "parse_action",
+    details: { received, validChoices: expected },
+    retryable: false
+  });
+}
+function parseChromeViewportArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.VIEWPORT);
+  const action = typeof obj.action === "string" ? obj.action : "set";
+  if (!VALID_VIEWPORT_ACTIONS.includes(action)) {
+    invalidAction(TOOL_NAMES.VIEWPORT, action, VALID_VIEWPORT_ACTIONS);
+  }
+  const target = parseTargetArgs(obj);
+  if (action === "list")
+    return { action: "list" };
+  if (action === "clear")
+    return { ...target, action: "clear" };
+  if (action === "preset") {
+    return { ...target, action: "preset", name: requireString(obj, "name", TOOL_NAMES.VIEWPORT) };
+  }
+  const width = Number(obj.width);
+  const height = Number(obj.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.VIEWPORT} set requires positive numeric width and height.`,
+      tool: TOOL_NAMES.VIEWPORT,
+      phase: "parse_dimensions",
+      details: { received: { width: obj.width, height: obj.height } },
+      retryable: false
+    });
+  }
+  const out = {
+    ...target,
+    action: "set",
+    width,
+    height
+  };
+  const dpr = optNumber(obj, "dpr");
+  if (dpr !== void 0)
+    out.dpr = dpr;
+  const mobile = optBool(obj, "mobile");
+  if (mobile !== void 0)
+    out.mobile = mobile;
+  const hasTouch = optBool(obj, "hasTouch");
+  if (hasTouch !== void 0)
+    out.hasTouch = hasTouch;
+  const userAgent = optString(obj, "userAgent");
+  if (userAgent)
+    out.userAgent = userAgent;
+  return out;
+}
+function parseLevels(input) {
+  if (input === void 0 || input === null)
+    return void 0;
+  const valid = new Set(VALID_CONSOLE_LEVELS);
+  const verify = (s) => {
+    if (typeof s !== "string" || !valid.has(s)) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `${TOOL_NAMES.CONSOLE}: invalid level ${JSON.stringify(s)}. Expected one of: ${VALID_CONSOLE_LEVELS.join(", ")}.`,
+        tool: TOOL_NAMES.CONSOLE,
+        phase: "parse_levels",
+        details: { received: s, validChoices: VALID_CONSOLE_LEVELS },
+        retryable: false
+      });
+    }
+    return s;
+  };
+  if (typeof input === "string")
+    return input.split(",").map((s) => verify(s.trim()));
+  if (Array.isArray(input))
+    return input.map(verify);
+  throw new RelayError({
+    code: "invalid_arguments",
+    message: `${TOOL_NAMES.CONSOLE}: invalid levels argument ${JSON.stringify(input)}. Expected a comma-separated string or an array of strings.`,
+    tool: TOOL_NAMES.CONSOLE,
+    phase: "parse_levels",
+    details: { received: input },
+    retryable: false
+  });
+}
+function parseChromeConsoleArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.CONSOLE);
+  const target = parseTargetArgs(obj);
+  const action = typeof obj.action === "string" ? obj.action : "read";
+  if (!VALID_CONSOLE_ACTIONS.includes(action)) {
+    invalidAction(TOOL_NAMES.CONSOLE, action, VALID_CONSOLE_ACTIONS);
+  }
+  if (action === "clear")
+    return { ...target, action: "clear" };
+  const out = { ...target, action: "read" };
+  const levels = parseLevels(obj.levels);
+  if (levels)
+    out.levels = levels;
+  const since = optNumber(obj, "since");
+  if (since !== void 0)
+    out.since = since;
+  const limit = optNumber(obj, "limit");
+  if (limit !== void 0)
+    out.limit = limit;
+  return out;
+}
+function parseChromeWorkspaceArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.WORKSPACE);
+  const action = typeof obj.action === "string" ? obj.action : "list";
+  if (!VALID_WORKSPACE_ACTIONS.includes(action)) {
+    invalidAction(TOOL_NAMES.WORKSPACE, action, VALID_WORKSPACE_ACTIONS);
+  }
+  if (action === "list")
+    return { action: "list" };
+  if (action === "close")
+    return { action: "close", name: requireString(obj, "name", TOOL_NAMES.WORKSPACE) };
+  const out = {
+    action: "create",
+    name: requireString(obj, "name", TOOL_NAMES.WORKSPACE)
+  };
+  const url = optString(obj, "url");
+  if (url)
+    out.url = url;
+  const label = optString(obj, "label");
+  if (label)
+    out.label = label;
+  return out;
+}
+function parseTabIds(raw) {
+  const reject = (bad) => {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.GROUP}: invalid tabId ${JSON.stringify(bad)}. Expected a number or a comma-separated list of numbers.`,
+      tool: TOOL_NAMES.GROUP,
+      phase: "parse_tab_ids",
+      details: { received: bad },
+      retryable: false
+    });
+  };
+  const coerce = (v) => {
+    const n = Number(typeof v === "string" ? v.trim() : v);
+    if (!Number.isFinite(n))
+      reject(v);
+    return n;
+  };
+  if (Array.isArray(raw))
+    return raw.map(coerce);
+  if (typeof raw === "string")
+    return raw.split(",").map(coerce);
+  if (typeof raw === "number")
+    return [raw];
+  return [];
+}
+function parseColor(raw) {
+  if (raw === void 0 || raw === null)
+    return void 0;
+  if (typeof raw !== "string") {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.GROUP}: invalid color ${JSON.stringify(raw)}. Expected one of: ${VALID_GROUP_COLORS.join(", ")}.`,
+      tool: TOOL_NAMES.GROUP,
+      phase: "parse_color",
+      details: { received: raw, validChoices: VALID_GROUP_COLORS },
+      retryable: false
+    });
+  }
+  const c = raw.toLowerCase();
+  if (!VALID_GROUP_COLORS.includes(c)) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.GROUP}: invalid color "${raw}". Expected one of: ${VALID_GROUP_COLORS.join(", ")}.`,
+      tool: TOOL_NAMES.GROUP,
+      phase: "parse_color",
+      details: { received: raw, validChoices: VALID_GROUP_COLORS },
+      retryable: false
+    });
+  }
+  return c;
+}
+function parseChromeGroupArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.GROUP);
+  const action = typeof obj.action === "string" ? obj.action : "list";
+  if (!VALID_GROUP_ACTIONS.includes(action)) {
+    invalidAction(TOOL_NAMES.GROUP, action, VALID_GROUP_ACTIONS);
+  }
+  if (action === "list")
+    return { action: "list" };
+  if (action === "close")
+    return { action: "close", name: requireString(obj, "name", TOOL_NAMES.GROUP) };
+  if (action === "remove") {
+    const tabIds2 = parseTabIds(obj.tabIds);
+    if (tabIds2.length === 0) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `${TOOL_NAMES.GROUP} remove requires tabIds.`,
+        tool: TOOL_NAMES.GROUP,
+        phase: "parse_arguments",
+        details: { field: "tabIds" },
+        retryable: false
+      });
+    }
+    return { action: "remove", tabIds: tabIds2 };
+  }
+  if (action === "add") {
+    const tabIds2 = parseTabIds(obj.tabIds);
+    if (tabIds2.length === 0) {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `${TOOL_NAMES.GROUP} add requires tabIds.`,
+        tool: TOOL_NAMES.GROUP,
+        phase: "parse_arguments",
+        details: { field: "tabIds" },
+        retryable: false
+      });
+    }
+    return { action: "add", name: requireString(obj, "name", TOOL_NAMES.GROUP), tabIds: tabIds2 };
+  }
+  const tabIds = parseTabIds(obj.tabIds);
+  if (tabIds.length === 0) {
+    throw new RelayError({
+      code: "invalid_arguments",
+      message: `${TOOL_NAMES.GROUP} create requires at least one tabId.`,
+      tool: TOOL_NAMES.GROUP,
+      phase: "parse_arguments",
+      details: { field: "tabIds" },
+      retryable: false
+    });
+  }
+  const out = {
+    action: "create",
+    name: requireString(obj, "name", TOOL_NAMES.GROUP),
+    tabIds
+  };
+  const color = parseColor(obj.color);
+  if (color)
+    out.color = color;
+  const collapsed = optBool(obj, "collapsed");
+  if (collapsed !== void 0)
+    out.collapsed = collapsed;
+  const windowId = optNumber(obj, "windowId");
+  if (windowId !== void 0)
+    out.windowId = windowId;
+  return out;
+}
+function parseChromeScreencastArgs(input) {
+  const obj = asObject(input, TOOL_NAMES.SCREENCAST);
+  const target = parseTargetArgs(obj);
+  const action = typeof obj.action === "string" ? obj.action : "start";
+  if (!VALID_SCREENCAST_ACTIONS.includes(action)) {
+    invalidAction(TOOL_NAMES.SCREENCAST, action, VALID_SCREENCAST_ACTIONS);
+  }
+  if (action === "stop")
+    return { ...target, action: "stop" };
+  const out = {
+    ...target,
+    action: "start"
+  };
+  if (obj.format !== void 0 && obj.format !== null) {
+    if (obj.format !== "jpeg" && obj.format !== "png") {
+      throw new RelayError({
+        code: "invalid_arguments",
+        message: `${TOOL_NAMES.SCREENCAST}: invalid format ${JSON.stringify(obj.format)}. Expected "jpeg" or "png".`,
+        tool: TOOL_NAMES.SCREENCAST,
+        phase: "parse_format",
+        details: { received: obj.format, validChoices: VALID_SCREENCAST_FORMATS },
+        retryable: false
+      });
+    }
+    out.format = obj.format;
+  }
+  const q = optNumber(obj, "quality");
+  if (q !== void 0)
+    out.quality = q;
+  const mw = optNumber(obj, "maxWidth");
+  if (mw !== void 0)
+    out.maxWidth = mw;
+  const mh = optNumber(obj, "maxHeight");
+  if (mh !== void 0)
+    out.maxHeight = mh;
+  const en = optNumber(obj, "everyNthFrame");
+  if (en !== void 0)
+    out.everyNthFrame = en;
+  return out;
+}
+var VALID_VIEWPORT_ACTIONS, VALID_CONSOLE_ACTIONS, VALID_CONSOLE_LEVELS, VALID_WORKSPACE_ACTIONS, VALID_GROUP_ACTIONS, VALID_GROUP_COLORS, VALID_SCREENCAST_ACTIONS, VALID_SCREENCAST_FORMATS;
+var init_multi = __esm({
+  "../protocol/dist/args/multi.js"() {
+    "use strict";
+    init_dist();
+    init_shared();
+    VALID_VIEWPORT_ACTIONS = ["set", "preset", "clear", "list"];
+    VALID_CONSOLE_ACTIONS = ["read", "clear"];
+    VALID_CONSOLE_LEVELS = ["log", "info", "warn", "error", "debug", "exception"];
+    VALID_WORKSPACE_ACTIONS = ["create", "list", "close"];
+    VALID_GROUP_ACTIONS = ["create", "list", "close", "add", "remove"];
+    VALID_GROUP_COLORS = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
+    VALID_SCREENCAST_ACTIONS = ["start", "stop"];
+    VALID_SCREENCAST_FORMATS = ["jpeg", "png"];
+  }
+});
+
+// ../protocol/dist/args/index.js
+var init_args = __esm({
+  "../protocol/dist/args/index.js"() {
+    "use strict";
+    init_shared();
+    init_navigate();
+    init_hover();
+    init_network();
+    init_simple();
+    init_multi();
+  }
+});
+
 // ../protocol/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -21,6 +729,33 @@ __export(dist_exports, {
   NATIVE_HOST_NAME: () => NATIVE_HOST_NAME,
   RelayError: () => RelayError,
   TOOL_NAMES: () => TOOL_NAMES,
+  asObject: () => asObject,
+  optBool: () => optBool,
+  optNumber: () => optNumber,
+  optString: () => optString,
+  parseChromeAxArgs: () => parseChromeAxArgs,
+  parseChromeClickArgs: () => parseChromeClickArgs,
+  parseChromeClickAxArgs: () => parseChromeClickAxArgs,
+  parseChromeCloseTabsArgs: () => parseChromeCloseTabsArgs,
+  parseChromeConsoleArgs: () => parseChromeConsoleArgs,
+  parseChromeEvaluateArgs: () => parseChromeEvaluateArgs,
+  parseChromeFillArgs: () => parseChromeFillArgs,
+  parseChromeGroupArgs: () => parseChromeGroupArgs,
+  parseChromeHoverArgs: () => parseChromeHoverArgs,
+  parseChromeKeyboardArgs: () => parseChromeKeyboardArgs,
+  parseChromeNavigateArgs: () => parseChromeNavigateArgs,
+  parseChromeNetworkArgs: () => parseChromeNetworkArgs,
+  parseChromeReadPageArgs: () => parseChromeReadPageArgs,
+  parseChromeScreencastArgs: () => parseChromeScreencastArgs,
+  parseChromeScreenshotArgs: () => parseChromeScreenshotArgs,
+  parseChromeSelfReloadArgs: () => parseChromeSelfReloadArgs,
+  parseChromeSwitchTabArgs: () => parseChromeSwitchTabArgs,
+  parseChromeTypeArgs: () => parseChromeTypeArgs,
+  parseChromeViewportArgs: () => parseChromeViewportArgs,
+  parseChromeWorkspaceArgs: () => parseChromeWorkspaceArgs,
+  parseGetWindowsAndTabsArgs: () => parseGetWindowsAndTabsArgs,
+  parseTargetArgs: () => parseTargetArgs,
+  requireString: () => requireString,
   toBridgeError: () => toBridgeError
 });
 function toBridgeError(unknownErr, fallbackTool) {
@@ -39,6 +774,7 @@ var NATIVE_HOST_NAME, DEFAULT_HTTP_PORT, CHROME_WEB_STORE_EXTENSION_ID, LEGACY_D
 var init_dist = __esm({
   "../protocol/dist/index.js"() {
     "use strict";
+    init_args();
     NATIVE_HOST_NAME = "dev.chrome_relay.native_host";
     DEFAULT_HTTP_PORT = 12122;
     CHROME_WEB_STORE_EXTENSION_ID = "cpdiapbifblhlcpnmlmfpgfjlacebokb";
@@ -130,7 +866,7 @@ var init_dist = __esm({
 import { Command } from "commander";
 
 // src/index.ts
-var CHROME_RELAY_VERSION = true ? "0.5.11" : "0.0.0-dev";
+var CHROME_RELAY_VERSION = true ? "0.5.13" : "0.0.0-dev";
 
 // src/commands/shared.ts
 init_dist();
@@ -364,6 +1100,19 @@ async function runDoctor() {
 
 // src/release-notes.ts
 var RELEASE_NOTES = {
+  "0.5.13": [
+    "Protocol arg-parser coverage complete (code-quality-hardening Risk 1 \u2014 finished). Every one of the 22 tools now has an executable parser in @chrome-relay/protocol that returns a typed args object with `code:'invalid_arguments'` errors on malformed input.",
+    "New parsers in this release: parseChrome{ReadPage,Click,Fill,Keyboard,Type,Evaluate,SwitchTab,CloseTabs,Ax,ClickAx,Screenshot,Viewport,Console,Workspace,Group,Screencast}Args, plus parseGetWindowsAndTabsArgs and parseChromeSelfReloadArgs.",
+    "All extension handlers now consume their parser at the top of the handler body \u2014 silent shape drift between CLI and extension is structurally impossible.",
+    "Multi-action tools (viewport, console, network, workspace, group, screencast) return discriminated unions so the handler branches with TypeScript narrowing instead of `typeof args.action === 'string'` boilerplate.",
+    "36 new tests in packages/protocol/test/args-all.test.ts. Total now 433 (was 397)."
+  ],
+  "0.5.12": [
+    "Protocol-owned tool arg parsers (code-quality-hardening Risk 1). New @chrome-relay/protocol exports: `parseChromeNavigateArgs`, `parseChromeHoverArgs`, `parseChromeNetworkArgs`. Each is the single source of truth for what its tool accepts \u2014 CLI and extension consume the same parser so silent shape drift can't happen.",
+    "Pattern established with 3 representative tools (navigate, hover, network \u2014 the doc-followup explicitly named these). Remaining 19 tools are mechanical follow-up (~20 lines + tests each). Each parser throws `RelayError(invalid_arguments)` with field/received/validChoices in details.",
+    "chrome_hover handler refactored to use the new parser end-to-end. Hover args now collapse into a discriminated union (`{kind:'selector', selector}` | `{kind:'coords', x, y}`) so the handler branches without re-doing the typeof dance.",
+    "19 new tests in packages/protocol/test/args.test.ts. Total now 397."
+  ],
   "0.5.11": [
     "Tests-only: 6 new edge-case tests for `chrome-relay update`. Covers --dry-run, install failure, install-success-but-binary-version-unchanged (PATH mismatch / stale shim), install-success-but-which-fails, install-success-but-release-notes-parse-fails, and the happy path. Locks in the structured-metadata contract from 0.5.7.",
     "Total tests now 378 (was 372)."

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-var CHROME_RELAY_VERSION = true ? "0.5.11" : "0.0.0-dev";
+var CHROME_RELAY_VERSION = true ? "0.5.13" : "0.0.0-dev";
 export {
   CHROME_RELAY_VERSION
 };

package/dist/native-host.js

@@ -48,7 +48,7 @@ function toBridgeError(unknownErr, fallbackTool) {
 }
 
 // src/index.ts
-var CHROME_RELAY_VERSION = true ? "0.5.11" : "0.0.0-dev";
+var CHROME_RELAY_VERSION = true ? "0.5.13" : "0.0.0-dev";
 
 // src/release-notes.ts
 function compareSemver(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-relay",
-  "version": "0.5.11",
+  "version": "0.5.13",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",