@vm0/cli 9.237.6 → 9.238.1

package/connector-R524H5MQ.js

@@ -0,0 +1,806 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  getPlatformOrigin
+} from "./chunk-ROLHZ5OO.js";
+import {
+  connectZeroConnectorManualGrant,
+  customConnectorProposalSchema,
+  getZeroAgent,
+  getZeroAgentCustomConnectors,
+  getZeroAgentUserConnectors,
+  getZeroCustomConnector,
+  listZeroConnectorCatalogStatus,
+  listZeroCustomConnectors
+} from "./chunk-37U2ZGBH.js";
+import "./chunk-LTDQISD7.js";
+import {
+  withErrorHandler
+} from "./chunk-VBI53K3Q.js";
+import {
+  source_default
+} from "./chunk-JUTUEPIR.js";
+import "./chunk-LRHXR7JT.js";
+import {
+  Command
+} from "./chunk-B3W2RUBP.js";
+import {
+  init_esm_shims
+} from "./chunk-DIRAZ3YX.js";
+
+// src/commands/zero/connector/index.ts
+init_esm_shims();
+
+// src/commands/zero/connector/connect.ts
+init_esm_shims();
+
+// src/commands/zero/connector/public-catalog.ts
+init_esm_shims();
+var TOKEN_BOUNDARY = /[_\-\s]+/;
+var CASE_BOUNDARY = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/;
+var MIN_SCORE = 10;
+function tokenize(input) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const chunk of input.split(TOKEN_BOUNDARY)) {
+    if (!chunk) continue;
+    for (const sub of chunk.split(CASE_BOUNDARY)) {
+      const lower = sub.toLowerCase();
+      if (lower) tokens.add(lower);
+    }
+  }
+  return tokens;
+}
+function publicStrings(connector) {
+  return [
+    connector.connectorRef,
+    connector.label,
+    connector.description,
+    connector.category,
+    ...connector.tags,
+    ...connector.generation,
+    ...connector.authMethods.flatMap((authMethod) => {
+      return [
+        authMethod.id,
+        authMethod.label,
+        ...authMethod.description ? [authMethod.description] : []
+      ];
+    })
+  ];
+}
+function best(candidates) {
+  return candidates.reduce((bestHit, hit) => {
+    if (!hit) return bestHit;
+    if (!bestHit || hit.score > bestHit.score) return hit;
+    return bestHit;
+  }, null);
+}
+function scoreExact(keywordLower, skipPrivateIdentifierMatches, connector) {
+  if (connector.connectorRef.toLowerCase() === keywordLower) {
+    return { score: 100, matchedField: "connectorRef" };
+  }
+  if (connector.label.toLowerCase() === keywordLower) {
+    return { score: 80, matchedField: "label" };
+  }
+  for (const tag of connector.tags) {
+    if (skipPrivateIdentifierMatches && tag.includes("_")) continue;
+    if (tag.toLowerCase() === keywordLower) {
+      return { score: 70, matchedField: `tag:${tag}` };
+    }
+  }
+  for (const generationType of connector.generation) {
+    if (generationType.toLowerCase() === keywordLower) {
+      return { score: 65, matchedField: `generation:${generationType}` };
+    }
+  }
+  for (const authMethod of connector.authMethods) {
+    if (authMethod.id.toLowerCase() === keywordLower) {
+      return { score: 60, matchedField: `auth-method:${authMethod.id}` };
+    }
+    if (authMethod.label.toLowerCase() === keywordLower) {
+      return { score: 60, matchedField: `auth-method:${authMethod.label}` };
+    }
+  }
+  if (connector.category.toLowerCase() === keywordLower) {
+    return { score: 55, matchedField: "category" };
+  }
+  return null;
+}
+function scoreSubstring(keywordLower, skipPrivateIdentifierMatches, connector) {
+  const candidates = [];
+  if (connector.connectorRef.toLowerCase().includes(keywordLower)) {
+    candidates.push({ score: 50, matchedField: "connectorRef" });
+  }
+  if (connector.label.toLowerCase().includes(keywordLower)) {
+    candidates.push({ score: 50, matchedField: "label" });
+  }
+  for (const tag of connector.tags) {
+    if (skipPrivateIdentifierMatches && tag.includes("_")) continue;
+    if (tag.toLowerCase().includes(keywordLower)) {
+      candidates.push({ score: 25, matchedField: `tag:${tag}` });
+    }
+  }
+  for (const generationType of connector.generation) {
+    if (generationType.toLowerCase().includes(keywordLower)) {
+      candidates.push({
+        score: 25,
+        matchedField: `generation:${generationType}`
+      });
+    }
+  }
+  for (const authMethod of connector.authMethods) {
+    if (authMethod.id.toLowerCase().includes(keywordLower) || authMethod.label.toLowerCase().includes(keywordLower)) {
+      candidates.push({
+        score: 20,
+        matchedField: `auth-method:${authMethod.id}`
+      });
+    }
+  }
+  if (connector.category.toLowerCase().includes(keywordLower)) {
+    candidates.push({ score: 20, matchedField: "category" });
+  }
+  if (connector.description.toLowerCase().includes(keywordLower)) {
+    candidates.push({ score: 15, matchedField: "description" });
+  }
+  return best(candidates);
+}
+function scoreTokens(keywordTokens, connector) {
+  const candidateTokens = /* @__PURE__ */ new Set();
+  for (const source of publicStrings(connector)) {
+    for (const token of tokenize(source)) {
+      candidateTokens.add(token);
+    }
+  }
+  let intersection = 0;
+  let firstCommon = "";
+  for (const token of keywordTokens) {
+    if (candidateTokens.has(token)) {
+      intersection++;
+      if (!firstCommon) firstCommon = token;
+    }
+  }
+  if (intersection === 0) return null;
+  return { score: 10 * intersection, matchedField: `token:${firstCommon}` };
+}
+function scoreConnector(keywordLower, keyword, keywordTokens, connector) {
+  const skipPrivateIdentifierMatches = /^[A-Za-z0-9_]+$/.test(keyword) && keyword.includes("_");
+  const tokenHit = skipPrivateIdentifierMatches ? null : scoreTokens(keywordTokens, connector);
+  const hit = best([
+    scoreExact(keywordLower, skipPrivateIdentifierMatches, connector),
+    scoreSubstring(keywordLower, skipPrivateIdentifierMatches, connector),
+    tokenHit
+  ]);
+  if (!hit || hit.score < MIN_SCORE) return null;
+  return hit;
+}
+function searchPublicConnectorCatalog(connectors, keyword, limit) {
+  const trimmed = keyword.trim();
+  if (!trimmed) return { results: [], total: 0 };
+  const keywordLower = trimmed.toLowerCase();
+  const keywordTokens = tokenize(trimmed);
+  const hits = connectors.flatMap(
+    (connector) => {
+      const hit = scoreConnector(
+        keywordLower,
+        trimmed,
+        keywordTokens,
+        connector
+      );
+      if (!hit) return [];
+      return [
+        {
+          connector,
+          score: hit.score,
+          matchedField: hit.matchedField
+        }
+      ];
+    }
+  );
+  hits.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.connector.connectorRef.localeCompare(b.connector.connectorRef);
+  });
+  return {
+    results: hits.slice(0, limit),
+    total: hits.length
+  };
+}
+function findConnectorStatusItem(connectors, connectorRef) {
+  const exact = connectors.find((connector) => {
+    return connector.connectorRef === connectorRef;
+  });
+  if (exact) return exact;
+  const lower = connectorRef.toLowerCase();
+  return connectors.find((connector) => {
+    return connector.connectorRef.toLowerCase() === lower;
+  }) ?? null;
+}
+function availableConnectorRefs(connectors) {
+  return connectors.map((connector) => {
+    return connector.connectorRef;
+  }).join(", ");
+}
+function resolveManualGrantAuthMethod(connector, rawAuthMethod) {
+  if (rawAuthMethod) {
+    const authMethod2 = connector.authMethods.find((method) => {
+      return method.id === rawAuthMethod;
+    });
+    if (!authMethod2) {
+      throw new Error(
+        `${connector.connectorRef} connector does not have ${rawAuthMethod} auth method`,
+        {
+          cause: new Error(
+            `Available auth methods: ${connector.authMethods.map((method) => {
+              return method.id;
+            }).join(", ")}`
+          )
+        }
+      );
+    }
+    if (authMethod2.grantKind === "manual") {
+      return authMethod2;
+    }
+    throw new Error(
+      `${connector.connectorRef} ${authMethod2.id} auth method does not use a manual grant`
+    );
+  }
+  const manualAuthMethods = connector.authMethods.filter((method) => {
+    return method.grantKind === "manual";
+  });
+  const authMethod = manualAuthMethods[0];
+  if (manualAuthMethods.length === 1 && authMethod) {
+    return authMethod;
+  }
+  if (manualAuthMethods.length === 0) {
+    throw new Error(
+      `${connector.connectorRef} connector does not use a manual grant`
+    );
+  }
+  throw new Error(
+    `${connector.connectorRef} connector has multiple manual grant auth methods`,
+    {
+      cause: new Error(
+        `Pass --auth-method ${manualAuthMethods.map((method) => {
+          return method.id;
+        }).join("|")}`
+      )
+    }
+  );
+}
+
+// src/commands/zero/connector/connect.ts
+function collectValue(value, previous) {
+  return [...previous, value];
+}
+function parseConnectorValues(rawValues) {
+  if (!rawValues || rawValues.length === 0) {
+    throw new Error("At least one --value NAME=VALUE is required", {
+      cause: new Error(
+        "Example: zero connector connect zendesk --value apiToken=token"
+      )
+    });
+  }
+  const values = {};
+  for (const rawValue of rawValues) {
+    const separatorIndex = rawValue.indexOf("=");
+    if (separatorIndex <= 0) {
+      throw new Error("Invalid --value format", {
+        cause: new Error("Use --value NAME=VALUE")
+      });
+    }
+    const name = rawValue.slice(0, separatorIndex);
+    if (!name.trim()) {
+      throw new Error("Invalid --value format", {
+        cause: new Error("Field name cannot be empty")
+      });
+    }
+    values[name] = rawValue.slice(separatorIndex + 1);
+  }
+  return values;
+}
+var connectCommand = new Command().name("connect").description("Connect a connector with manual grant values").argument("<type>", "Connector type (e.g., zendesk)").option("--auth-method <method>", "Connector auth method to use").option(
+  "--value <name=value>",
+  "Connector field value; repeat for multiple fields",
+  collectValue,
+  []
+).option("--json", "Print the connector response as JSON").action(
+  withErrorHandler(async (type, options) => {
+    const values = parseConnectorValues(options.value);
+    const catalog = await listZeroConnectorCatalogStatus();
+    const connectorMetadata = findConnectorStatusItem(
+      catalog.connectors,
+      type
+    );
+    if (!connectorMetadata) {
+      throw new Error(`Unknown or unavailable connector: ${type}`, {
+        cause: new Error(
+          `Available connectors: ${availableConnectorRefs(catalog.connectors)}`
+        )
+      });
+    }
+    const authMethod = resolveManualGrantAuthMethod(
+      connectorMetadata,
+      options.authMethod
+    );
+    const connector = await connectZeroConnectorManualGrant(
+      connectorMetadata.connectorRef,
+      authMethod.id,
+      values
+    );
+    if (options.json) {
+      console.log(JSON.stringify(connector, null, 2));
+      return;
+    }
+    console.log(source_default.green(`\u2713 ${connectorMetadata.label} connected`));
+    console.log(source_default.dim(`  Type: ${connector.type}`));
+    console.log(source_default.dim(`  Auth Method: ${connector.authMethod}`));
+    console.log(source_default.dim(`  Run: zero connector status ${connector.type}`));
+  })
+);
+
+// src/commands/zero/connector/list.ts
+init_esm_shims();
+
+// src/commands/zero/connector/agent-context.ts
+init_esm_shims();
+async function resolveAgentContext(flagAgentId) {
+  const agentId = flagAgentId ?? process.env.ZERO_AGENT_ID;
+  if (!agentId) return null;
+  const [agent, enabledTypes] = await Promise.all([
+    getZeroAgent(agentId),
+    getZeroAgentUserConnectors(agentId)
+  ]);
+  return {
+    agentId: agent.agentId,
+    displayName: agent.displayName ?? agent.agentId,
+    authorizedTypes: new Set(enabledTypes)
+  };
+}
+
+// src/commands/zero/connector/connected-as.ts
+init_esm_shims();
+function renderIdentity(connector) {
+  if (connector.connection?.externalUsername) {
+    return `@${connector.connection.externalUsername}`;
+  }
+  if (connector.connection?.externalEmail)
+    return connector.connection.externalEmail;
+  return "-";
+}
+function renderConnectedAsCell(connector) {
+  if (!connector || connector.connectionStatus === "not-connected") {
+    return source_default.dim("(not connected)");
+  }
+  const identity = renderIdentity(connector);
+  if (connector.connectionStatus === "reconnect-required") {
+    return source_default.yellow(`${identity} (reconnect needed)`);
+  }
+  if (connector.scopeMismatch || connector.connectionStatus === "scope-mismatch") {
+    return source_default.yellow(`${identity} (permissions update available)`);
+  }
+  return identity;
+}
+var ESC = "\x1B";
+var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+function stripAnsi(s) {
+  return s.replace(ANSI_PATTERN, "");
+}
+function padEndAnsi(s, width) {
+  const visible = stripAnsi(s).length;
+  return s + " ".repeat(Math.max(0, width - visible));
+}
+
+// src/commands/zero/connector/list.ts
+var listCommand = new Command().name("list").alias("ls").description("List all connectors and their status").option("--agent <id>", "Show per-agent authorization column").action(
+  withErrorHandler(async (options) => {
+    const [{ connectors }, agentCtx] = await Promise.all([
+      listZeroConnectorCatalogStatus(),
+      resolveAgentContext(options.agent)
+    ]);
+    const allTypes = connectors.map((connector) => {
+      return connector.connectorRef;
+    });
+    const typeWidth = Math.max(
+      4,
+      ...allTypes.map((t) => {
+        return t.length;
+      })
+    );
+    const connectedAsHeader = "CONNECTED AS";
+    const connectedCells = connectors.map((connector) => {
+      return renderConnectedAsCell(connector);
+    });
+    const connectedAsWidth = Math.max(
+      connectedAsHeader.length,
+      ...connectedCells.map((c) => {
+        return stripAnsi(c).length;
+      })
+    );
+    const authorizedHeader = agentCtx ? `AUTHORIZED FOR ${agentCtx.displayName}` : null;
+    const headerParts = [
+      "TYPE".padEnd(typeWidth),
+      connectedAsHeader.padEnd(connectedAsWidth)
+    ];
+    if (authorizedHeader) headerParts.push(authorizedHeader);
+    console.log(source_default.dim(headerParts.join("  ")));
+    for (let i = 0; i < allTypes.length; i++) {
+      const type = allTypes[i];
+      const connectedCell = padEndAnsi(connectedCells[i], connectedAsWidth);
+      const parts = [type.padEnd(typeWidth), connectedCell];
+      if (agentCtx) {
+        parts.push(
+          agentCtx.authorizedTypes.has(type) ? source_default.green("\u2713") : source_default.dim("-")
+        );
+      }
+      console.log(parts.join("  "));
+    }
+  })
+);
+
+// src/commands/zero/connector/search.ts
+init_esm_shims();
+var DEFAULT_LIMIT = 5;
+var EXACT_MATCH_THRESHOLD = 80;
+function parseLimit(raw) {
+  const trimmed = raw.trim();
+  const n = Number(trimmed);
+  if (!/^\d+$/.test(trimmed) || !Number.isSafeInteger(n) || n <= 0) {
+    throw new Error(`--limit must be a positive integer, got "${raw}".`);
+  }
+  return n;
+}
+var searchCommand = new Command().name("search").description(
+  "Search connectors by type, label, category, generation type, or tag"
+).argument("<keyword>", "Search keyword (case-insensitive)").option("--agent <id>", "Show per-agent authorization column").option(
+  "--limit <n>",
+  `Maximum number of results to display (default ${DEFAULT_LIMIT})`,
+  parseLimit,
+  DEFAULT_LIMIT
+).action(
+  withErrorHandler(
+    async (keyword, options) => {
+      const trimmed = keyword.trim();
+      if (!trimmed) {
+        throw new Error("Keyword cannot be empty.");
+      }
+      const [{ connectors }, agentCtx] = await Promise.all([
+        listZeroConnectorCatalogStatus(),
+        resolveAgentContext(options.agent)
+      ]);
+      const { results, total } = searchPublicConnectorCatalog(
+        connectors,
+        trimmed,
+        options.limit
+      );
+      if (results.length === 0) {
+        console.log("No matches found.");
+        return;
+      }
+      const topScore = results[0].score;
+      if (topScore < EXACT_MATCH_THRESHOLD) {
+        console.log("No exact match. Showing closest:");
+      }
+      if (total > options.limit) {
+        console.log(`Too many results (top ${options.limit} of ${total}):`);
+      }
+      const typeHeader = "TYPE";
+      const connectedAsHeader = "CONNECTED AS";
+      const connectedCells = results.map((r) => {
+        return renderConnectedAsCell(r.connector);
+      });
+      const typeWidth = Math.max(
+        typeHeader.length,
+        ...results.map((r) => {
+          return r.connector.connectorRef.length;
+        })
+      );
+      const connectedAsWidth = Math.max(
+        connectedAsHeader.length,
+        ...connectedCells.map((c) => {
+          return stripAnsi(c).length;
+        })
+      );
+      const headerParts = [
+        typeHeader.padEnd(typeWidth),
+        connectedAsHeader.padEnd(connectedAsWidth)
+      ];
+      if (agentCtx) {
+        headerParts.push(`AUTHORIZED FOR ${agentCtx.displayName}`);
+      }
+      console.log(source_default.dim(headerParts.join("  ")));
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const parts = [
+          result.connector.connectorRef.padEnd(typeWidth),
+          padEndAnsi(connectedCells[i], connectedAsWidth)
+        ];
+        if (agentCtx) {
+          parts.push(
+            agentCtx.authorizedTypes.has(result.connector.connectorRef) ? source_default.green("\u2713") : source_default.dim("-")
+          );
+        }
+        console.log(parts.join("  "));
+      }
+    }
+  )
+);
+
+// src/commands/zero/connector/status.ts
+init_esm_shims();
+var LABEL_WIDTH = 16;
+function printConnectorDetails(connector) {
+  if (connector.connectionStatus === "not-connected") {
+    console.log(
+      `${"Status:".padEnd(LABEL_WIDTH)}${source_default.dim("not connected")}`
+    );
+    return;
+  }
+  console.log(
+    `${"Status:".padEnd(LABEL_WIDTH)}${connector.connectionStatus === "reconnect-required" ? source_default.yellow("reconnect needed") : source_default.green("connected")}`
+  );
+  if (connector.connection?.externalUsername) {
+    console.log(
+      `${"Account:".padEnd(LABEL_WIDTH)}@${connector.connection.externalUsername}`
+    );
+  } else if (connector.connection?.externalEmail) {
+    console.log(
+      `${"Account:".padEnd(LABEL_WIDTH)}${connector.connection.externalEmail}`
+    );
+  }
+  if (connector.connection?.authMethod) {
+    console.log(
+      `${"Auth Method:".padEnd(LABEL_WIDTH)}${connector.connection.authMethod}`
+    );
+  }
+  if (connector.scopeMismatch) {
+    console.log(
+      `${"Permissions:".padEnd(LABEL_WIDTH)}${source_default.yellow("update available")}`
+    );
+  }
+  if (connector.tokenExpiresAt) {
+    console.log(
+      `${"Token Expires:".padEnd(LABEL_WIDTH)}${connector.tokenExpiresAt}`
+    );
+  }
+}
+async function printAgentAction(connector, agentCtx) {
+  const connectorRef = connector.connectorRef;
+  const authorized = agentCtx.authorizedTypes.has(connectorRef);
+  const isConnected = connector.connected;
+  const needsReconnect = connector.connectionStatus === "reconnect-required";
+  const agentLabel = agentCtx.displayName === agentCtx.agentId ? agentCtx.agentId : `${agentCtx.displayName} (${agentCtx.agentId})`;
+  console.log();
+  if (needsReconnect) {
+    const origin = await getPlatformOrigin();
+    const url = `${origin}/connectors`;
+    console.log(
+      `The ${connectorRef} connector is connected but needs to be reconnected before agent ${agentLabel} can use it.`
+    );
+    console.log(`Reconnect it at: [Reconnect ${connectorRef}](${url})`);
+  } else if (authorized && !isConnected) {
+    const origin = await getPlatformOrigin();
+    const url = `${origin}/connectors/${connectorRef}/connect?agentId=${agentCtx.agentId}`;
+    console.log(
+      `The ${connectorRef} connector is authorized for agent ${agentLabel}, but it is not connected.`
+    );
+    console.log(`Connect it at: [Connect ${connectorRef}](${url})`);
+  } else if (authorized) {
+    console.log(
+      `The ${connectorRef} connector is authorized for agent ${agentLabel}.`
+    );
+  } else if (!isConnected) {
+    const origin = await getPlatformOrigin();
+    const url = `${origin}/connectors/${connectorRef}/connect?agentId=${agentCtx.agentId}`;
+    console.log(
+      `The ${connectorRef} connector is not connected. Once connected, it will be authorized for agent ${agentLabel}.`
+    );
+    console.log(
+      `Connect and authorize it at: [Connect ${connectorRef}](${url})`
+    );
+  } else {
+    const origin = await getPlatformOrigin();
+    const url = `${origin}/connectors/${connectorRef}/authorize?agentId=${agentCtx.agentId}`;
+    console.log(
+      `The ${connectorRef} connector is not authorized for agent ${agentLabel}.`
+    );
+    console.log(`Authorize it at: [Authorize ${connectorRef}](${url})`);
+  }
+}
+async function printStandaloneAction(connector) {
+  const connectorRef = connector.connectorRef;
+  if (connector.connectionStatus === "connected" || connector.connectionStatus === "scope-mismatch") {
+    return;
+  }
+  const origin = await getPlatformOrigin();
+  console.log();
+  if (connector.connectionStatus === "reconnect-required") {
+    const url = `${origin}/connectors`;
+    console.log(
+      `The ${connectorRef} connector is connected but needs to be reconnected.`
+    );
+    console.log(`Reconnect it at: [Reconnect ${connectorRef}](${url})`);
+  } else {
+    const url = `${origin}/connectors/${connectorRef}/connect`;
+    console.log(`Connect it at: [Connect ${connectorRef}](${url})`);
+  }
+}
+var statusCommand = new Command().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").option("--agent <id>", "Show authorization state for the given agent").action(
+  withErrorHandler(async (type, options) => {
+    const [catalog, agentCtx] = await Promise.all([
+      listZeroConnectorCatalogStatus(),
+      resolveAgentContext(options.agent)
+    ]);
+    const connector = findConnectorStatusItem(catalog.connectors, type);
+    if (!connector) {
+      throw new Error(`Unknown or unavailable connector: ${type}`, {
+        cause: new Error(
+          `Available connectors: ${availableConnectorRefs(catalog.connectors)}`
+        )
+      });
+    }
+    console.log(`Connector: ${source_default.cyan(connector.connectorRef)}`);
+    console.log();
+    printConnectorDetails(connector);
+    if (agentCtx) {
+      await printAgentAction(connector, agentCtx);
+    } else {
+      await printStandaloneAction(connector);
+    }
+  })
+);
+
+// src/commands/zero/connector/custom/index.ts
+init_esm_shims();
+import { readFile } from "fs/promises";
+var LABEL_WIDTH2 = 18;
+function renderConnected(connector) {
+  if (connector.connected) {
+    return source_default.green("connected");
+  }
+  if (connector.missingRequiredFields.length === 0) {
+    return source_default.dim("not connected");
+  }
+  return source_default.yellow(`missing ${connector.missingRequiredFields.join(", ")}`);
+}
+function encodeBase64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function resolveCustomAgentContext(agentId) {
+  const resolvedAgentId = agentId ?? process.env.ZERO_AGENT_ID;
+  if (!resolvedAgentId) {
+    return null;
+  }
+  const [agent, enabledIds] = await Promise.all([
+    getZeroAgent(resolvedAgentId),
+    getZeroAgentCustomConnectors(resolvedAgentId)
+  ]);
+  return {
+    agentId: agent.agentId,
+    displayName: agent.displayName ?? agent.agentId,
+    authorizedIds: new Set(enabledIds)
+  };
+}
+var listCommand2 = new Command().name("list").alias("ls").description("List org custom connectors").option("--agent <id>", "Show per-agent authorization column").action(
+  withErrorHandler(async (options) => {
+    const [connectors, agentCtx] = await Promise.all([
+      listZeroCustomConnectors(),
+      resolveCustomAgentContext(options.agent)
+    ]);
+    const idWidth = Math.max(
+      2,
+      ...connectors.map((connector) => {
+        return connector.id.length;
+      })
+    );
+    const nameWidth = Math.max(
+      4,
+      ...connectors.map((connector) => {
+        return connector.displayName.length;
+      })
+    );
+    const header = ["ID".padEnd(idWidth), "NAME".padEnd(nameWidth), "STATUS"];
+    if (agentCtx) {
+      header.push(`AUTHORIZED FOR ${agentCtx.displayName}`);
+    }
+    console.log(source_default.dim(header.join("  ")));
+    for (const connector of connectors) {
+      const row = [
+        connector.id.padEnd(idWidth),
+        connector.displayName.padEnd(nameWidth),
+        renderConnected(connector)
+      ];
+      if (agentCtx) {
+        row.push(
+          agentCtx.authorizedIds.has(connector.id) ? source_default.green("\u2713") : source_default.dim("-")
+        );
+      }
+      console.log(row.join("  "));
+    }
+  })
+);
+var statusCommand2 = new Command().name("status").description("Show detailed status of a custom connector").argument("<connector-id>", "Custom connector id").option("--agent <id>", "Show authorization state for the given agent").action(
+  withErrorHandler(
+    async (connectorId, options) => {
+      const [connector, agentCtx] = await Promise.all([
+        getZeroCustomConnector(connectorId),
+        resolveCustomAgentContext(options.agent)
+      ]);
+      if (!connector) {
+        throw new Error(`Custom connector not found: ${connectorId}`);
+      }
+      console.log(`Custom connector: ${source_default.cyan(connector.displayName)}`);
+      console.log();
+      console.log(`${"ID:".padEnd(LABEL_WIDTH2)}${connector.id}`);
+      console.log(
+        `${"Status:".padEnd(LABEL_WIDTH2)}${renderConnected(connector)}`
+      );
+      console.log(
+        `${"Prefixes:".padEnd(LABEL_WIDTH2)}${connector.prefixTemplates.join(", ")}`
+      );
+      console.log(
+        `${"Fields:".padEnd(LABEL_WIDTH2)}${connector.fields.map((field) => {
+          return `${field.kind}:${field.key}${field.required ? "" : "?"}`;
+        }).join(", ")}`
+      );
+      if (connector.headerInjections.length > 0) {
+        console.log(
+          `${"Headers:".padEnd(LABEL_WIDTH2)}${connector.headerInjections.map((header) => {
+            return header.name;
+          }).join(", ")}`
+        );
+      }
+      if (connector.queryInjections.length > 0) {
+        console.log(
+          `${"Query params:".padEnd(LABEL_WIDTH2)}${connector.queryInjections.map((query) => {
+            return query.name;
+          }).join(", ")}`
+        );
+      }
+      if (agentCtx) {
+        console.log(
+          `${"Authorized:".padEnd(LABEL_WIDTH2)}${agentCtx.authorizedIds.has(connector.id) ? source_default.green("yes") : source_default.yellow("no")}`
+        );
+      }
+    }
+  )
+);
+var proposeCommand = new Command().name("propose").description("Create a browser save link for a custom connector proposal").requiredOption("--proposal-file <path>", "JSON proposal file").option("--connector-id <id>", "Override connector id for update proposals").option("--agent <id>", "Authorize this agent when the proposal is saved").action(
+  withErrorHandler(
+    async (options) => {
+      const raw = await readFile(options.proposalFile, "utf8");
+      const proposalJson = JSON.parse(raw);
+      if (!isJsonObject(proposalJson)) {
+        throw new Error("Proposal file must contain a JSON object");
+      }
+      const parsed = customConnectorProposalSchema.parse({
+        ...proposalJson,
+        ...options.connectorId ? { connectorId: options.connectorId } : {}
+      });
+      const origin = await getPlatformOrigin();
+      const params = new URLSearchParams({
+        p: encodeBase64UrlJson(parsed)
+      });
+      const agentId = options.agent ?? process.env.ZERO_AGENT_ID;
+      if (agentId) {
+        params.set("agentId", agentId);
+      }
+      const url = `${origin}/connectors/custom/proposal?${params.toString()}`;
+      console.log(`[Configure ${parsed.displayName}](${url})`);
+      console.log();
+      console.log(
+        "Open this link to review, save values, and authorize the connector."
+      );
+    }
+  )
+);
+var customConnectorCommand = new Command().name("custom").description("Inspect and propose org custom connectors").addCommand(listCommand2).addCommand(statusCommand2).addCommand(proposeCommand);
+
+// src/commands/zero/connector/index.ts
+var zeroConnectorCommand = new Command().name("connector").description("Check third-party service connections (GitHub, Slack, etc.)").addCommand(customConnectorCommand).addCommand(connectCommand).addCommand(listCommand).addCommand(searchCommand).addCommand(statusCommand);
+export {
+  zeroConnectorCommand
+};
+//# sourceMappingURL=connector-R524H5MQ.js.map