@vm0/cli 9.221.4 → 9.221.5

package/{connector-WBM4EKRR.js → connector-YJX3MZGN.js}

@@ -1,35 +1,22 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "node:module";
 const require = __createRequire(import.meta.url);
-import {
-  formatDateTime
-} from "./chunk-RGP625TN.js";
 import {
   getPlatformOrigin
 } from "./chunk-ZFETZTKV.js";
-import {
-  getConfiguredConnectorAuthMethodIds,
-  getConnectorAuthMethod,
-  getConnectorAuthMethodScopeDiff,
-  getConnectorEnvBindingEntries,
-  hasRequiredConnectorAuthMethodScopes
-} from "./chunk-DAC5OAWI.js";
 import "./chunk-LTDQISD7.js";
 import {
-  CONNECTOR_TYPES,
-  CONNECTOR_TYPE_KEYS,
   connectZeroConnectorManualGrant,
+  connectorAuthMethodIdSchema,
   connectorTypeSchema,
   customConnectorProposalSchema,
   getZeroAgent,
   getZeroAgentCustomConnectors,
   getZeroAgentUserConnectors,
-  getZeroConnector,
   getZeroCustomConnector,
-  listZeroConnectors,
-  listZeroCustomConnectors,
-  searchZeroConnectors
-} from "./chunk-QV73BJ3B.js";
+  listZeroConnectorCatalogStatus,
+  listZeroCustomConnectors
+} from "./chunk-PCBM5SRN.js";
 import {
   withErrorHandler
 } from "./chunk-3F4RFLPX.js";
@@ -49,87 +36,293 @@ init_esm_shims();
 
 // src/commands/zero/connector/connect.ts
 init_esm_shims();
-function collectValue(value, previous) {
-  return [...previous, value];
+
+// 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 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 ZENDESK_API_TOKEN=token"
-      )
-    });
+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" };
   }
-  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")
+  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}`
       });
     }
-    const name = rawValue.slice(0, separatorIndex);
-    if (!name.trim()) {
-      throw new Error("Invalid --value format", {
-        cause: new Error("Field name cannot be empty")
+  }
+  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}`
       });
     }
-    values[name] = rawValue.slice(separatorIndex + 1);
   }
-  return values;
+  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 parseConnectorType(type) {
-  const parsed = connectorTypeSchema.safeParse(type);
-  if (parsed.success) {
-    return parsed.data;
+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;
+    }
   }
-  throw new Error(`Unknown connector type: ${type}`, {
-    cause: new Error(`Available connectors: ${CONNECTOR_TYPE_KEYS.join(", ")}`)
+  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 parseConfiguredAuthMethod(type, rawAuthMethod) {
-  const configuredAuthMethodIds = getConfiguredConnectorAuthMethodIds(type);
-  const authMethod = configuredAuthMethodIds.find((method) => {
-    return method === rawAuthMethod;
+function findConnectorStatusItem(connectors, connectorRef) {
+  const exact = connectors.find((connector) => {
+    return connector.connectorRef === connectorRef;
   });
-  if (authMethod) {
-    return authMethod;
-  }
+  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 parseConnectorTypeForAction(connectorRef) {
+  const parsed = connectorTypeSchema.safeParse(connectorRef);
+  if (parsed.success) return parsed.data;
   throw new Error(
-    `${type} connector does not have ${rawAuthMethod} auth method`,
+    `Connector ${connectorRef} cannot be used by this CLI action`,
     {
       cause: new Error(
-        `Available auth methods: ${configuredAuthMethodIds.join(", ")}`
+        "This action still uses the connector action API, which only accepts built-in connector refs."
       )
     }
   );
 }
-function getManualGrantAuthMethods(type) {
-  return getConfiguredConnectorAuthMethodIds(type).filter((authMethod) => {
-    return getConnectorAuthMethod(type, authMethod)?.grant.kind === "manual";
-  });
+function parseConnectorAuthMethodIdForAction(authMethodId) {
+  const parsed = connectorAuthMethodIdSchema.safeParse(authMethodId);
+  if (parsed.success) return parsed.data;
+  throw new Error(
+    `Auth method ${authMethodId} cannot be used by this CLI action`,
+    {
+      cause: new Error(
+        "This action still uses the connector action API, which only accepts built-in auth method ids."
+      )
+    }
+  );
 }
-function parseManualGrantAuthMethod(type, rawAuthMethod) {
+function resolveManualGrantAuthMethod(connector, rawAuthMethod) {
   if (rawAuthMethod) {
-    const authMethod2 = parseConfiguredAuthMethod(type, rawAuthMethod);
-    if (getConnectorAuthMethod(type, authMethod2)?.grant.kind === "manual") {
+    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(
-      `${type} ${authMethod2} auth method does not use a manual grant`
+      `${connector.connectorRef} ${authMethod2.id} auth method does not use a manual grant`
     );
   }
-  const authMethods = getManualGrantAuthMethods(type);
-  const authMethod = authMethods[0];
-  if (authMethods.length === 1 && authMethod) {
+  const manualAuthMethods = connector.authMethods.filter((method) => {
+    return method.grantKind === "manual";
+  });
+  const authMethod = manualAuthMethods[0];
+  if (manualAuthMethods.length === 1 && authMethod) {
     return authMethod;
   }
-  if (authMethods.length === 0) {
-    throw new Error(`${type} connector does not use a manual grant`);
+  if (manualAuthMethods.length === 0) {
+    throw new Error(
+      `${connector.connectorRef} connector does not use a manual grant`
+    );
   }
-  throw new Error(`${type} connector has multiple manual grant auth methods`, {
-    cause: new Error(`Pass --auth-method ${authMethods.join("|")}`)
-  });
+  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>",
@@ -138,23 +331,36 @@ var connectCommand = new Command().name("connect").description("Connect a connec
   []
 ).option("--json", "Print the connector response as JSON").action(
   withErrorHandler(async (type, options) => {
-    const connectorType = parseConnectorType(type);
-    const authMethod = parseManualGrantAuthMethod(
-      connectorType,
+    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 connectorType = parseConnectorTypeForAction(
+      connectorMetadata.connectorRef
+    );
+    const authMethod = resolveManualGrantAuthMethod(
+      connectorMetadata,
       options.authMethod
     );
     const connector = await connectZeroConnectorManualGrant(
       connectorType,
-      authMethod,
-      parseConnectorValues(options.value)
+      parseConnectorAuthMethodIdForAction(authMethod.id),
+      values
     );
     if (options.json) {
       console.log(JSON.stringify(connector, null, 2));
       return;
     }
-    console.log(
-      source_default.green(`\u2713 ${CONNECTOR_TYPES[connectorType].label} connected`)
-    );
+    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}`));
@@ -183,22 +389,22 @@ async function resolveAgentContext(flagAgentId) {
 // src/commands/zero/connector/connected-as.ts
 init_esm_shims();
 function renderIdentity(connector) {
-  if (connector.externalUsername) return `@${connector.externalUsername}`;
-  if (connector.externalEmail) return connector.externalEmail;
+  if (connector.connection?.externalUsername) {
+    return `@${connector.connection.externalUsername}`;
+  }
+  if (connector.connection?.externalEmail)
+    return connector.connection.externalEmail;
   return "-";
 }
 function renderConnectedAsCell(connector) {
-  if (!connector) return source_default.dim("(not connected)");
+  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)`);
   }
-  const scopeMismatch = !hasRequiredConnectorAuthMethodScopes(
-    connector.type,
-    connector.authMethod,
-    connector.oauthScopes
-  );
-  if (scopeMismatch) {
+  if (connector.scopeMismatch || connector.connectionStatus === "scope-mismatch") {
     return source_default.yellow(`${identity} (permissions update available)`);
   }
   return identity;
@@ -214,24 +420,15 @@ function padEndAnsi(s, width) {
 }
 
 // src/commands/zero/connector/list.ts
-function isConnectorType(type) {
-  return type in CONNECTOR_TYPES;
-}
 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 }, availableCatalog, agentCtx] = await Promise.all([
-      listZeroConnectors(),
-      searchZeroConnectors(),
+    const [{ connectors }, agentCtx] = await Promise.all([
+      listZeroConnectorCatalogStatus(),
       resolveAgentContext(options.agent)
     ]);
-    const connectedMap = new Map(
-      connectors.map((c) => {
-        return [c.type, c];
-      })
-    );
-    const allTypes = availableCatalog.connectors.map((connector) => {
-      return connector.id;
-    }).filter(isConnectorType);
+    const allTypes = connectors.map((connector) => {
+      return connector.connectorRef;
+    });
     const typeWidth = Math.max(
       4,
       ...allTypes.map((t) => {
@@ -239,8 +436,8 @@ var listCommand = new Command().name("list").alias("ls").description("List all c
       })
     );
     const connectedAsHeader = "CONNECTED AS";
-    const connectedCells = allTypes.map((type) => {
-      return renderConnectedAsCell(connectedMap.get(type));
+    const connectedCells = connectors.map((connector) => {
+      return renderConnectedAsCell(connector);
     });
     const connectedAsWidth = Math.max(
       connectedAsHeader.length,
@@ -271,189 +468,18 @@ var listCommand = new Command().name("list").alias("ls").description("List all c
 
 // src/commands/zero/connector/search.ts
 init_esm_shims();
-
-// ../../packages/connectors/src/connector-search.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 connectorAccessEnvBindings(access) {
-  switch (access.kind) {
-    case "static":
-    case "refresh-token":
-      return access.envBindings;
-    case "none":
-      return {};
-  }
-}
-function getManualGrantFields(method) {
-  return method.grant.kind === "manual" ? method.grant.fields : void 0;
-}
-function connectorEnvBindingValueRef(value) {
-  return typeof value === "string" ? value : value.valueRef;
-}
-function listSecretNames(config) {
-  const names = [];
-  for (const method of Object.values(config.authMethods)) {
-    for (const name of Object.keys(getManualGrantFields(method) ?? {})) {
-      names.push(name);
-    }
-    for (const valueRef of Object.values(
-      connectorAccessEnvBindings(method.access)
-    )) {
-      const ref = connectorEnvBindingValueRef(valueRef);
-      if (ref.startsWith("$secrets.")) {
-        names.push(ref.slice("$secrets.".length));
-      }
-    }
-  }
-  return names;
-}
-function listEnvNames(type) {
-  return [
-    ...new Set(
-      getConnectorEnvBindingEntries(type).map(({ envName }) => {
-        return envName;
-      })
-    )
-  ];
-}
-function findExactMatch(keywordLower, type, config) {
-  if (type.toLowerCase() === keywordLower) {
-    return { score: 100, matchedField: "type" };
-  }
-  for (const envName of listEnvNames(type)) {
-    if (envName.toLowerCase() === keywordLower) {
-      return { score: 90, matchedField: `env:${envName}` };
-    }
-  }
-  if (config.label.toLowerCase() === keywordLower) {
-    return { score: 80, matchedField: "label" };
-  }
-  const tags = config.tags ?? [];
-  for (const tag of tags) {
-    if (tag === keywordLower) {
-      return { score: 70, matchedField: `tag:${tag}` };
-    }
-  }
-  return null;
-}
-function findSubstringMatch(keywordLower, type, config) {
-  if (type.toLowerCase().includes(keywordLower)) {
-    return { score: 50, matchedField: "type" };
-  }
-  if (config.label.toLowerCase().includes(keywordLower)) {
-    return { score: 50, matchedField: "label" };
-  }
-  for (const envName of listEnvNames(type)) {
-    if (envName.toLowerCase().includes(keywordLower)) {
-      return { score: 40, matchedField: `env:${envName}` };
-    }
-  }
-  for (const name of listSecretNames(config)) {
-    if (name.toLowerCase().includes(keywordLower)) {
-      return { score: 30, matchedField: `secret:${name}` };
-    }
-  }
-  const tags = config.tags ?? [];
-  for (const tag of tags) {
-    if (tag.includes(keywordLower)) {
-      return { score: 25, matchedField: `tag:${tag}` };
-    }
-  }
-  return null;
-}
-function collectCandidateTokens(type, config) {
-  const tokens = /* @__PURE__ */ new Set();
-  const sources = [
-    type,
-    config.label,
-    ...listEnvNames(type),
-    ...listSecretNames(config),
-    ...config.tags ?? []
-  ];
-  for (const source of sources) {
-    for (const token of tokenize(source)) {
-      tokens.add(token);
-    }
-  }
-  return tokens;
-}
-function findTokenIntersection(keywordTokens, type, config) {
-  const candidateTokens = collectCandidateTokens(type, config);
-  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, keywordTokens, type, config) {
-  const exact = findExactMatch(keywordLower, type, config);
-  if (exact) return exact;
-  const candidates = [];
-  const substring = findSubstringMatch(keywordLower, type, config);
-  if (substring) candidates.push(substring);
-  const token = findTokenIntersection(keywordTokens, type, config);
-  if (token) candidates.push(token);
-  if (candidates.length === 0) return null;
-  const best = candidates.reduce((a, b) => {
-    return a.score >= b.score ? a : b;
-  });
-  if (best.score < MIN_SCORE) return null;
-  return best;
-}
-function searchConnectors(keyword, limit, filter) {
-  const trimmed = keyword.trim();
-  if (!trimmed) return { results: [], total: 0 };
-  const keywordLower = trimmed.toLowerCase();
-  const keywordTokens = tokenize(trimmed);
-  const hits = [];
-  for (const type of CONNECTOR_TYPE_KEYS) {
-    if (filter && !filter(type)) continue;
-    const config = CONNECTOR_TYPES[type];
-    const hit = scoreConnector(keywordLower, keywordTokens, type, config);
-    if (!hit) continue;
-    hits.push({ type, score: hit.score, matchedField: hit.matchedField });
-  }
-  hits.sort((a, b) => {
-    if (b.score !== a.score) return b.score - a.score;
-    return a.type.localeCompare(b.type);
-  });
-  const capped = limit > 0 ? hits.slice(0, limit) : hits;
-  return { results: capped, total: hits.length };
-}
-
-// src/commands/zero/connector/search.ts
 var DEFAULT_LIMIT = 5;
 var EXACT_MATCH_THRESHOLD = 80;
-function isConnectorType2(type) {
-  return type in CONNECTOR_TYPES;
-}
 function parseLimit(raw) {
-  const n = Number.parseInt(raw, 10);
-  if (!Number.isFinite(n) || n <= 0) {
+  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, environment name, secret, or tag"
+  "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})`,
@@ -466,27 +492,14 @@ var searchCommand = new Command().name("search").description(
       if (!trimmed) {
         throw new Error("Keyword cannot be empty.");
       }
-      const [{ connectors }, availableCatalog, agentCtx] = await Promise.all([
-        listZeroConnectors(),
-        searchZeroConnectors(),
+      const [{ connectors }, agentCtx] = await Promise.all([
+        listZeroConnectorCatalogStatus(),
         resolveAgentContext(options.agent)
       ]);
-      const connectedMap = new Map(
-        connectors.map((c) => {
-          return [c.type, c];
-        })
-      );
-      const availableTypes = new Set(
-        availableCatalog.connectors.map((connector) => {
-          return connector.id;
-        }).filter(isConnectorType2)
-      );
-      const { results, total } = searchConnectors(
+      const { results, total } = searchPublicConnectorCatalog(
+        connectors,
         trimmed,
-        options.limit,
-        (type) => {
-          return availableTypes.has(type);
-        }
+        options.limit
       );
       if (results.length === 0) {
         console.log("No matches found.");
@@ -502,12 +515,12 @@ var searchCommand = new Command().name("search").description(
       const typeHeader = "TYPE";
       const connectedAsHeader = "CONNECTED AS";
       const connectedCells = results.map((r) => {
-        return renderConnectedAsCell(connectedMap.get(r.type));
+        return renderConnectedAsCell(r.connector);
       });
       const typeWidth = Math.max(
         typeHeader.length,
         ...results.map((r) => {
-          return r.type.length;
+          return r.connector.connectorRef.length;
         })
       );
       const connectedAsWidth = Math.max(
@@ -527,12 +540,12 @@ var searchCommand = new Command().name("search").description(
       for (let i = 0; i < results.length; i++) {
         const result = results[i];
         const parts = [
-          result.type.padEnd(typeWidth),
+          result.connector.connectorRef.padEnd(typeWidth),
           padEndAnsi(connectedCells[i], connectedAsWidth)
         ];
         if (agentCtx) {
           parts.push(
-            agentCtx.authorizedTypes.has(result.type) ? source_default.green("\u2713") : source_default.dim("-")
+            agentCtx.authorizedTypes.has(result.connector.connectorRef) ? source_default.green("\u2713") : source_default.dim("-")
           );
         }
         console.log(parts.join("  "));
@@ -544,149 +557,123 @@ var searchCommand = new Command().name("search").description(
 // src/commands/zero/connector/status.ts
 init_esm_shims();
 var LABEL_WIDTH = 16;
-function isConnectorType3(type) {
-  return type in CONNECTOR_TYPES;
-}
-async function availableConnectorTypes() {
-  const catalog = await searchZeroConnectors();
-  return new Set(
-    catalog.connectors.map((connector) => {
-      return connector.id;
-    }).filter(isConnectorType3)
+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")}`
   );
-}
-function printConnectorDetails(type, connector) {
-  if (connector) {
+  if (connector.connection?.externalUsername) {
     console.log(
-      `${"Status:".padEnd(LABEL_WIDTH)}${connector.connectionStatus === "reconnect-required" ? source_default.yellow("reconnect needed") : source_default.green("connected")}`
+      `${"Account:".padEnd(LABEL_WIDTH)}@${connector.connection.externalUsername}`
     );
+  } else if (connector.connection?.externalEmail) {
     console.log(
-      `${"Account:".padEnd(LABEL_WIDTH)}@${connector.externalUsername}`
+      `${"Account:".padEnd(LABEL_WIDTH)}${connector.connection.externalEmail}`
     );
-    console.log(`${"Auth Method:".padEnd(LABEL_WIDTH)}${connector.authMethod}`);
-    if (connector.oauthScopes && connector.oauthScopes.length > 0) {
-      console.log(
-        `${"OAuth Scopes:".padEnd(LABEL_WIDTH)}${connector.oauthScopes.join(", ")}`
-      );
-    }
-    if (!hasRequiredConnectorAuthMethodScopes(
-      type,
-      connector.authMethod,
-      connector.oauthScopes
-    )) {
-      const diff = getConnectorAuthMethodScopeDiff(
-        type,
-        connector.authMethod,
-        connector.oauthScopes
-      );
-      console.log(
-        `${"Permissions:".padEnd(LABEL_WIDTH)}${source_default.yellow("update available")}`
-      );
-      if (diff.addedScopes.length > 0) {
-        console.log(
-          `${"  Added:".padEnd(LABEL_WIDTH)}${diff.addedScopes.join(", ")}`
-        );
-      }
-      if (diff.removedScopes.length > 0) {
-        console.log(
-          `${"  Removed:".padEnd(LABEL_WIDTH)}${diff.removedScopes.join(", ")}`
-        );
-      }
-    }
+  }
+  if (connector.connection?.authMethod) {
     console.log(
-      `${"Connected:".padEnd(LABEL_WIDTH)}${formatDateTime(connector.createdAt)}`
+      `${"Auth Method:".padEnd(LABEL_WIDTH)}${connector.connection.authMethod}`
     );
-    if (connector.updatedAt !== connector.createdAt) {
-      console.log(
-        `${"Last Updated:".padEnd(LABEL_WIDTH)}${formatDateTime(connector.updatedAt)}`
-      );
-    }
-  } else {
+  }
+  if (connector.scopeMismatch) {
     console.log(
-      `${"Status:".padEnd(LABEL_WIDTH)}${source_default.dim("not connected")}`
+      `${"Permissions:".padEnd(LABEL_WIDTH)}${source_default.yellow("update available")}`
+    );
+  }
+  if (connector.tokenExpiresAt) {
+    console.log(
+      `${"Token Expires:".padEnd(LABEL_WIDTH)}${connector.tokenExpiresAt}`
     );
   }
 }
-async function printAgentAction(type, connector, agentCtx) {
-  const authorized = agentCtx.authorizedTypes.has(type);
-  const isConnected = connector !== null;
-  const needsReconnect = connector?.connectionStatus === "reconnect-required";
+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 ${type} connector is connected but needs to be reconnected before agent ${agentLabel} can use it.`
+      `The ${connectorRef} connector is connected but needs to be reconnected before agent ${agentLabel} can use it.`
     );
-    console.log(`Reconnect it at: [Reconnect ${type}](${url})`);
+    console.log(`Reconnect it at: [Reconnect ${connectorRef}](${url})`);
   } else if (authorized && !isConnected) {
     const origin = await getPlatformOrigin();
-    const url = `${origin}/connectors/${type}/connect?agentId=${agentCtx.agentId}`;
+    const url = `${origin}/connectors/${connectorRef}/connect?agentId=${agentCtx.agentId}`;
     console.log(
-      `The ${type} connector is authorized for agent ${agentLabel}, but it is not connected.`
+      `The ${connectorRef} connector is authorized for agent ${agentLabel}, but it is not connected.`
     );
-    console.log(`Connect it at: [Connect ${type}](${url})`);
+    console.log(`Connect it at: [Connect ${connectorRef}](${url})`);
   } else if (authorized) {
-    console.log(`The ${type} connector is authorized for agent ${agentLabel}.`);
+    console.log(
+      `The ${connectorRef} connector is authorized for agent ${agentLabel}.`
+    );
   } else if (!isConnected) {
     const origin = await getPlatformOrigin();
-    const url = `${origin}/connectors/${type}/connect?agentId=${agentCtx.agentId}`;
+    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(
-      `The ${type} connector is not connected. Once connected, it will be authorized for agent ${agentLabel}.`
+      `Connect and authorize it at: [Connect ${connectorRef}](${url})`
     );
-    console.log(`Connect and authorize it at: [Connect ${type}](${url})`);
   } else {
     const origin = await getPlatformOrigin();
-    const url = `${origin}/connectors/${type}/authorize?agentId=${agentCtx.agentId}`;
+    const url = `${origin}/connectors/${connectorRef}/authorize?agentId=${agentCtx.agentId}`;
     console.log(
-      `The ${type} connector is not authorized for agent ${agentLabel}.`
+      `The ${connectorRef} connector is not authorized for agent ${agentLabel}.`
     );
-    console.log(`Authorize it at: [Authorize ${type}](${url})`);
+    console.log(`Authorize it at: [Authorize ${connectorRef}](${url})`);
   }
 }
-async function printStandaloneAction(type, connector) {
-  if (connector?.connectionStatus === "connected") return;
+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") {
+  if (connector.connectionStatus === "reconnect-required") {
     const url = `${origin}/connectors`;
     console.log(
-      `The ${type} connector is connected but needs to be reconnected.`
+      `The ${connectorRef} connector is connected but needs to be reconnected.`
     );
-    console.log(`Reconnect it at: [Reconnect ${type}](${url})`);
+    console.log(`Reconnect it at: [Reconnect ${connectorRef}](${url})`);
   } else {
-    const url = `${origin}/connectors/${type}/connect`;
-    console.log(`Connect it at: [Connect ${type}](${url})`);
+    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 parseResult = connectorTypeSchema.safeParse(type);
-    if (!parseResult.success) {
-      const available2 = CONNECTOR_TYPE_KEYS.join(", ");
-      throw new Error(`Unknown connector type: ${type}`, {
-        cause: new Error(`Available connectors: ${available2}`)
-      });
-    }
-    const [connector, availableTypes, agentCtx] = await Promise.all([
-      getZeroConnector(parseResult.data),
-      availableConnectorTypes(),
+    const [catalog, agentCtx] = await Promise.all([
+      listZeroConnectorCatalogStatus(),
       resolveAgentContext(options.agent)
     ]);
-    const available = availableTypes.has(parseResult.data);
-    console.log(`Connector: ${source_default.cyan(type)}`);
-    console.log();
-    printConnectorDetails(parseResult.data, connector);
-    if (!available) {
-      console.log();
-      console.log(`The ${type} connector is not available for this account.`);
-      return;
+    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(parseResult.data, connector, agentCtx);
+      await printAgentAction(connector, agentCtx);
     } else {
-      await printStandaloneAction(parseResult.data, connector);
+      await printStandaloneAction(connector);
     }
   })
 );
@@ -845,4 +832,4 @@ var zeroConnectorCommand = new Command().name("connector").description("Check th
 export {
   zeroConnectorCommand
 };
-//# sourceMappingURL=connector-WBM4EKRR.js.map
+//# sourceMappingURL=connector-YJX3MZGN.js.map