pushary 1.8.0

package/dist/chunk-3EVPNIBE.js

@@ -0,0 +1,185 @@
+import {
+  NOTIFICATION_MATCHED_TYPES,
+  POSTTOOLUSE_MIRRORED_TOOLS
+} from "./chunk-EPCXUP3P.js";
+import {
+  isProtectedByScope,
+  registerHookEntry
+} from "./chunk-A2A2YTMG.js";
+import {
+  CLAUDE_PRETOOLUSE_MATCHER,
+  HOOK_BUDGETS,
+  HOOK_LOCATOR_BINARY
+} from "./chunk-NQTHFF4W.js";
+
+// src/gemini-config.ts
+var GEMINI_HOOK_BINARY = "pushary-gemini-hook";
+var GEMINI_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var GEMINI_HOOK_EVENTS = [
+  { event: "BeforeTool", matcher: "run_shell_command|write_file|replace|mcp_.*", delivery: "approval", timeoutMs: HOOK_BUDGETS.gemini.budgetSeconds * 1e3 },
+  { event: "AfterTool", matcher: "run_shell_command|write_file|replace|mcp_.*", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "BeforeAgent", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "AfterAgent", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionStart", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionEnd", delivery: "telemetry", timeoutMs: 1e4 }
+];
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyGeminiHook = (entry, scope) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    if (isProtectedByScope(command, scope)) return false;
+    return command.includes(GEMINI_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
+  });
+};
+var addGeminiMcpServer = (settings, apiKey) => {
+  const mcpServers = ensureRecord(settings, "mcpServers");
+  mcpServers.pushary = {
+    httpUrl: GEMINI_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` },
+    trust: true
+  };
+};
+var addGeminiHooks = (settings, command) => {
+  const hooks = ensureRecord(settings, "hooks");
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    hooks[definition.event] = registerHookEntry(existing, isPusharyGeminiHook, {
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        name: "pushary",
+        type: "command",
+        command,
+        timeout: definition.timeoutMs
+      }]
+    });
+  }
+};
+var removeGeminiHooks = (settings, scope) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of GEMINI_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isPusharyGeminiHook(entry, scope));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete settings.hooks;
+  return changed;
+};
+var removeGeminiMcpServer = (settings) => {
+  const mcpServers = asRecord(settings.mcpServers);
+  if (!mcpServers?.pushary) return false;
+  delete mcpServers.pushary;
+  if (Object.keys(mcpServers).length === 0) delete settings.mcpServers;
+  return true;
+};
+var removeGeminiSettings = (settings, scope) => {
+  const mcpRemoved = scope?.keepMcpServer === true ? false : removeGeminiMcpServer(settings);
+  const hooksRemoved = removeGeminiHooks(settings, scope);
+  return mcpRemoved || hooksRemoved;
+};
+var hasGeminiHooks = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  return GEMINI_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some((entry) => isPusharyGeminiHook(entry));
+  });
+};
+var missingGeminiHookEvents = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  return GEMINI_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some((entry) => isPusharyGeminiHook(entry));
+  }).map((definition) => definition.event);
+};
+
+// src/agent-version.ts
+var parseVersion = (raw) => {
+  const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+var compareVersion = (a, b) => {
+  for (let index = 0; index < 3; index++) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+};
+var atLeast = (version, floor) => compareVersion(version, floor) >= 0;
+var formatVersion = (version) => version.join(".");
+
+// src/claude-events.ts
+var MIRRORED_TOOLS = POSTTOOLUSE_MIRRORED_TOOLS.join("|");
+var ESTABLISHED = [1, 0, 0];
+var OBSERVED = [2, 0, 0];
+var CLAUDE_HOOK_BINARY = "pushary-hook";
+var CLAUDE_HOOK_EVENTS = [
+  { event: "PreToolUse", binary: CLAUDE_HOOK_BINARY, matcher: CLAUDE_PRETOOLUSE_MATCHER, timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: NOTIFICATION_MATCHED_TYPES.join("|"), timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", holds: true, since: ESTABLISHED },
+  // Observability only. Each carries session shape the island cannot get any other
+  // way, and none of them decides anything.
+  { event: "SubagentStart", binary: "pushary-session-start-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  // An MCP server asking the person for a value, answered from the phone rather
+  // than the terminal. No matcher: Claude Code matches this event on the MCP
+  // server's name, and we have no business preferring one server over another.
+  { event: "Elicitation", binary: "pushary-elicitation-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: OBSERVED }
+];
+var supportedClaudeEvents = (version) => CLAUDE_HOOK_EVENTS.filter((hook) => version ? atLeast(version, hook.since) : hook.since === ESTABLISHED);
+var registrationSignatures = (events, version) => Object.fromEntries(
+  events.map((hook) => [hook.event, `registered|${version ? formatVersion(version) : "unknown"}`])
+);
+var needsReregistration = (stored, version) => {
+  const expected = registrationSignatures(supportedClaudeEvents(version), version);
+  const keys = Object.keys(expected);
+  if (!stored) return true;
+  if (keys.length !== Object.keys(stored).length) return true;
+  return keys.some((event) => stored[event] !== expected[event]);
+};
+
+export {
+  GEMINI_HOOK_BINARY,
+  GEMINI_HOOK_EVENTS,
+  addGeminiMcpServer,
+  addGeminiHooks,
+  removeGeminiMcpServer,
+  removeGeminiSettings,
+  hasGeminiHooks,
+  missingGeminiHookEvents,
+  parseVersion,
+  compareVersion,
+  formatVersion,
+  CLAUDE_HOOK_BINARY,
+  CLAUDE_HOOK_EVENTS,
+  supportedClaudeEvents,
+  registrationSignatures,
+  needsReregistration
+};

package/dist/chunk-5OP5MQI7.js

@@ -0,0 +1,45 @@
+import {
+  DEFAULT_SESSION
+} from "./chunk-N6IOSZOE.js";
+
+// src/answer.ts
+var denyReasonFrom = (value, note) => {
+  const trimmed = note?.trim();
+  if (trimmed) return `Denied from your phone: ${trimmed}`;
+  return value && value !== "no" && value !== "yes" ? `Denied from your phone: ${value}` : "Denied via push notification";
+};
+var isDeferAnswer = (value) => value === "defer";
+
+// src/session-notice.ts
+import { existsSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var SUBSCRIPTION_REQUIRED_NOTICE_KIND = "subscription-required";
+var oncePerSession = (kind, sessionId) => {
+  try {
+    const key = (sessionId || DEFAULT_SESSION).replace(/[^a-zA-Z0-9_-]/g, "");
+    const marker = join(tmpdir(), `pushary-${kind}-${key}`);
+    if (existsSync(marker)) return false;
+    writeFileSync(marker, "1", "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var subscriptionRequiredNotice = (upgradeUrl) => `[pushary] Your Pushary workspace has no active subscription, so approvals stay with your agent. Subscribe: ${upgradeUrl}`;
+var announceSubscriptionRequired = (upgradeUrl, sessionId) => {
+  try {
+    if (!oncePerSession(SUBSCRIPTION_REQUIRED_NOTICE_KIND, sessionId)) return;
+    process.stderr.write(`${subscriptionRequiredNotice(upgradeUrl)}
+`);
+  } catch {
+    return;
+  }
+};
+
+export {
+  denyReasonFrom,
+  isDeferAnswer,
+  oncePerSession,
+  announceSubscriptionRequired
+};

package/dist/chunk-6J2JC2RT.js

@@ -0,0 +1,149 @@
+import {
+  CLAUDE_HOOK_EVENTS,
+  GEMINI_HOOK_EVENTS,
+  hasGeminiHooks
+} from "./chunk-3EVPNIBE.js";
+import {
+  CODEX_HOOK_EVENTS,
+  hasCodexHooks,
+  holdBudgetOf
+} from "./chunk-A2A2YTMG.js";
+import {
+  CURSOR_GATE_EVENTS,
+  HOOK_LOCATOR_BINARY,
+  hookCommandHoldBudget
+} from "./chunk-NQTHFF4W.js";
+
+// src/diagnostics/wiring.ts
+var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var CLAUDE_HOOK_BINARY = /pushary-[a-z-]*hook/;
+var EXACT_HOOK_BINARY = /^pushary-[a-z-]*(hook|gate)$/;
+var pusharyHookExecutable = (command) => {
+  const tokens = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  for (const raw of tokens.reverse()) {
+    const token = raw[0] === '"' && raw.at(-1) === '"' || raw[0] === "'" && raw.at(-1) === "'" ? raw.slice(1, -1) : raw;
+    const name = token.split(/[/\\]/).pop()?.replace(/\.(cmd|exe|mjs)$/i, "") ?? "";
+    if (name === HOOK_LOCATOR_BINARY || EXACT_HOOK_BINARY.test(name)) return token;
+  }
+  return null;
+};
+var claudeWired = ({ claudeJson, settings, skillExists }) => {
+  if (record(record(claudeJson)?.mcpServers)?.pushary) return true;
+  const s = record(settings);
+  if (s) {
+    const hooks = JSON.stringify(s.hooks ?? {});
+    if (CLAUDE_HOOK_BINARY.test(hooks) || hooks.includes(HOOK_LOCATOR_BINARY)) return true;
+    const allow = record(s.permissions)?.allow;
+    if (Array.isArray(allow) && allow.some((rule) => String(rule).includes("mcp__pushary__"))) return true;
+  }
+  return skillExists;
+};
+var codexWired = ({ config, hooks, skillExists }) => {
+  if (record(record(config)?.mcp_servers)?.pushary) return true;
+  const h = record(hooks);
+  if (h && hasCodexHooks(h)) return true;
+  return skillExists;
+};
+var geminiWired = ({ settings }) => {
+  const s = record(settings);
+  if (!s) return false;
+  if (record(s.mcpServers)?.pushary) return true;
+  return hasGeminiHooks(s);
+};
+var cursorWired = ({ userHooks, mcp, pluginDirExists }) => {
+  if (pluginDirExists) return true;
+  if (record(record(mcp)?.mcpServers)?.pushary) return true;
+  const hooks = record(record(userHooks)?.hooks);
+  if (!hooks) return false;
+  return Object.values(hooks).some((entries) => Array.isArray(entries) && entries.some((entry) => pusharyHookExecutable(String(record(entry)?.command ?? "")) !== null));
+};
+var cursorMcpAuthorization = (pluginMcp, userMcp) => {
+  const pluginServers = record(record(pluginMcp)?.mcpServers);
+  const usePlugin = pluginServers !== null && Object.hasOwn(pluginServers, "pushary");
+  const servers = usePlugin ? pluginServers : record(record(userMcp)?.mcpServers);
+  const headers = record(record(servers?.pushary)?.headers);
+  return {
+    authorization: typeof headers?.Authorization === "string" ? headers.Authorization : null,
+    source: usePlugin ? "plugin mcp.json" : "~/.cursor/mcp.json"
+  };
+};
+var LONG_HOLD_SECONDS = 600;
+var toSeconds = (timeout, unit) => {
+  if (typeof timeout !== "number" || !Number.isFinite(timeout)) return null;
+  return unit === "milliseconds" ? timeout / 1e3 : timeout;
+};
+var registeredHooks = (entries, shape, unit) => {
+  if (!Array.isArray(entries)) return [];
+  return entries.flatMap((entry) => {
+    const container = record(entry);
+    if (!container) return [];
+    const hooks = shape === "nested" ? Array.isArray(container.hooks) ? container.hooks : [] : [container];
+    return hooks.flatMap((hook) => {
+      const command = record(hook)?.command;
+      if (typeof command !== "string" || command.trim() === "") return [];
+      return [{ command, timeoutSeconds: toSeconds(record(hook)?.timeout, unit) }];
+    });
+  });
+};
+var holdersOnEvent = (event, hooks) => {
+  if (!hooks.some((hook) => pusharyHookExecutable(hook.command) !== null)) return [];
+  return hooks.filter((hook) => pusharyHookExecutable(hook.command) === null).map((hook) => ({ event, command: hook.command, timeoutSeconds: hook.timeoutSeconds }));
+};
+var otherHolders = (hooks, events, shape, unit) => {
+  const table = record(hooks);
+  if (!table) return [];
+  return events.flatMap((event) => holdersOnEvent(event, registeredHooks(table[event], shape, unit)));
+};
+var approvalEvents = (table) => table.filter((hook) => hook.delivery === "approval").map((hook) => hook.event);
+var CLAUDE_GATE_EVENTS = approvalEvents(CLAUDE_HOOK_EVENTS);
+var CODEX_GATE_EVENTS = approvalEvents(CODEX_HOOK_EVENTS);
+var GEMINI_GATE_EVENTS = approvalEvents(GEMINI_HOOK_EVENTS);
+var claudeOtherHolders = (settings) => otherHolders(record(settings)?.hooks, CLAUDE_GATE_EVENTS, "nested", "seconds");
+var codexOtherHolders = (hooks) => otherHolders(record(hooks)?.hooks, CODEX_GATE_EVENTS, "nested", "seconds");
+var geminiOtherHolders = (settings) => otherHolders(record(settings)?.hooks, GEMINI_GATE_EVENTS, "nested", "milliseconds");
+var cursorOtherHolders = (userHooks) => otherHolders(record(userHooks)?.hooks, CURSOR_GATE_EVENTS, "flat", "seconds");
+var holdEvents = (table) => table.flatMap((hook) => {
+  const seconds = holdBudgetOf(hook);
+  return seconds === void 0 ? [] : [{ event: hook.event, seconds }];
+});
+var unprovenHolds = (hooks, events) => {
+  const table = record(hooks);
+  if (!table) return [];
+  return events.filter(({ event, seconds }) => registeredHooks(table[event], "nested", "seconds").some((hook) => pusharyHookExecutable(hook.command) !== null && hookCommandHoldBudget(hook.command) !== seconds)).map(({ event }) => event);
+};
+var claudeUnprovenHolds = (settings) => unprovenHolds(record(settings)?.hooks, holdEvents(CLAUDE_HOOK_EVENTS));
+var codexUnprovenHolds = (hooks) => unprovenHolds(record(hooks)?.hooks, holdEvents(CODEX_HOOK_EVENTS));
+var holdsLong = (holder) => holder.timeoutSeconds !== null && holder.timeoutSeconds > LONG_HOLD_SECONDS;
+var SHELLS = /* @__PURE__ */ new Set(["/bin/sh", "/bin/bash", "/bin/zsh", "/usr/bin/env"]);
+var holderExecutable = (command) => {
+  const pathLike = command.match(/[^\s"']*[/\\][^\s"']*/g) ?? [];
+  const target = pathLike.find((token) => !SHELLS.has(token));
+  return target ?? command.trim().split(/\s+/)[0] ?? command;
+};
+var describeHoldTimeout = (holder) => {
+  const seconds = holder.timeoutSeconds;
+  if (seconds === null) return "no timeout set, so the agent default applies";
+  if (seconds >= 3600 && seconds % 3600 === 0) return `${seconds / 3600}h timeout`;
+  if (seconds >= 60 && seconds % 60 === 0) return `${seconds / 60}m timeout`;
+  return `${seconds}s timeout`;
+};
+var describeOtherHolder = (holder) => `another hook also registered on ${holder.event}: ${holderExecutable(holder.command)} (${describeHoldTimeout(holder)})`;
+var describeHoldSentence = (agentLabel) => `${agentLabel} waits for every hook on an event, so the terminal cannot move until that one returns, however fast your phone answered.`;
+
+export {
+  pusharyHookExecutable,
+  claudeWired,
+  codexWired,
+  geminiWired,
+  cursorWired,
+  cursorMcpAuthorization,
+  claudeOtherHolders,
+  codexOtherHolders,
+  geminiOtherHolders,
+  cursorOtherHolders,
+  claudeUnprovenHolds,
+  codexUnprovenHolds,
+  holdsLong,
+  describeOtherHolder,
+  describeHoldSentence
+};

package/dist/chunk-7QLSKOSU.js

@@ -0,0 +1,19 @@
+// src/cli/errors.ts
+var UsageError = class extends Error {
+  constructor(hint) {
+    super(hint);
+    this.hint = hint;
+    this.name = "UsageError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+
+export {
+  UsageError,
+  NetworkError
+};

package/dist/chunk-7Z7Q4GGS.js

@@ -0,0 +1,88 @@
+import {
+  SETUP_FLAGS
+} from "./chunk-ZVSKMPBZ.js";
+import {
+  parseFlags
+} from "./chunk-GMXKITVA.js";
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+import {
+  CLAUDE_CONNECTOR_GUIDE,
+  CLAUDE_CONNECTOR_STEPS,
+  CLAUDE_CONNECTOR_TEST,
+  CLAUDE_CONNECTOR_URL,
+  COWORK_CONNECTOR_LIMIT,
+  COWORK_STANDING_INSTRUCTIONS
+} from "./chunk-NQTHFF4W.js";
+
+// src/cli/cowork.ts
+import { readFileSync } from "fs";
+var coworkSetup = {
+  status: "manual_setup_required",
+  connectorUrl: CLAUDE_CONNECTOR_URL,
+  guideUrl: CLAUDE_CONNECTOR_GUIDE,
+  steps: CLAUDE_CONNECTOR_STEPS,
+  testPrompt: CLAUDE_CONNECTOR_TEST,
+  instructions: COWORK_STANDING_INSTRUCTIONS,
+  capability: COWORK_CONNECTOR_LIMIT
+};
+var renderCoworkSetup = () => [
+  "Claude Desktop / Cowork setup",
+  "",
+  CLAUDE_CONNECTOR_URL,
+  "",
+  ...CLAUDE_CONNECTOR_STEPS.map((step, i) => `${i + 1}. ${step}`),
+  "",
+  `Test prompt: ${CLAUDE_CONNECTOR_TEST}`,
+  "",
+  COWORK_CONNECTOR_LIMIT,
+  "",
+  "Cowork supports plugin hooks on supported versions. This connector setup does not install or verify native permission hooks.",
+  "Run pushary cowork --instructions for the standing instructions, or --skill for the uploadable SKILL.md.",
+  `Full guide: ${CLAUDE_CONNECTOR_GUIDE}`,
+  ""
+].join("\n");
+var parseCoworkOptions = (argv) => {
+  const flags = parseFlags(argv, { bools: ["json", "open", "instructions", "skill", "help", "h"], values: [] });
+  if (flags.command && flags.command !== "cowork" || flags.rest.length > 0) {
+    throw new UsageError("cowork takes no positional arguments. Run pushary cowork --help.");
+  }
+  const formats = ["json", "instructions", "skill"].filter((flag) => flags.bools.has(flag));
+  if (formats.length > 1) throw new UsageError("Choose only one of --json, --instructions, or --skill.");
+  return { format: formats[0] ?? "guide", open: flags.bools.has("open") };
+};
+var coworkOutput = (format) => {
+  if (format === "json") return JSON.stringify(coworkSetup, null, 2) + "\n";
+  if (format === "instructions") return COWORK_STANDING_INSTRUCTIONS + "\n";
+  if (format === "skill") {
+    for (const relative of ["../../data/cowork/SKILL.md", "../data/cowork/SKILL.md"]) {
+      try {
+        return readFileSync(new URL(relative, import.meta.url), "utf8");
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    throw new Error("Packaged Cowork skill is missing. Reinstall @pushary/agent-hooks.");
+  }
+  return renderCoworkSetup();
+};
+var coworkSelection = (argv) => {
+  const flags = parseFlags(argv, SETUP_FLAGS);
+  const selected = flags.values.get("agents")?.toLowerCase().split(",").map((value) => value.trim()) ?? [];
+  const aliases = /* @__PURE__ */ new Set(["cowork", "claude_cowork", "claude_desktop", "claude_chat"]);
+  if (!selected.some((value) => aliases.has(value))) return null;
+  if (selected.some((value) => !aliases.has(value)) || flags.rest.length > 0 || flags.command && flags.command !== "setup") {
+    throw new UsageError("Set up Cowork with pushary cowork, then run setup separately for your CLI agents.");
+  }
+  if ([...flags.values.keys()].some((key) => key !== "agents") || flags.bools.has("key-stdin") || flags.bools.has("take-over-hooks")) {
+    throw new UsageError("Cowork uses connector OAuth. Use pushary cowork; CLI key, control, and hook options do not apply.");
+  }
+  return { json: flags.bools.has("json") };
+};
+
+export {
+  parseCoworkOptions,
+  coworkOutput,
+  coworkSelection
+};