@integrity-labs/agt-cli 0.28.369 → 0.28.371

package/dist/{chunk-RIWZIYJ7.js → chunk-NDF3YMP5.js}

@@ -8922,6 +8922,282 @@ function generateAgentsMd(input) {
   return out.join("\n");
 }
 
+// ../../packages/core/dist/provisioning/remote-mcp.js
+function envVarForToken(definitionId) {
+  return `${definitionId.replace(/-/g, "_").toUpperCase()}_ACCESS_TOKEN`;
+}
+function credentialEnvVar(definitionId, credentialRef) {
+  const idPart = definitionId.replace(/-/g, "_").toUpperCase();
+  const credPart = credentialRef.replace(/-/g, "_").toUpperCase();
+  return `${idPart}_${credPart}`;
+}
+function assertSafeRemoteMcpUrl(url, definitionId) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    throw new Error(`remoteMcp.url for '${definitionId}' is not a valid URL: ${url}`);
+  }
+  if (u.protocol !== "https:") {
+    throw new Error(`remoteMcp.url for '${definitionId}' must be https (got ${u.protocol}//): ${url}`);
+  }
+  const host = u.hostname.toLowerCase();
+  const blocked = host === "localhost" || host === "169.254.169.254" || // AWS/GCP/Azure instance metadata
+  host === "metadata.google.internal" || /^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host) || /^169\.254\./.test(host) || // link-local
+  /^172\.(1[6-9]|2\d|3[01])\./.test(host) || // 172.16.0.0/12
+  host.endsWith(".internal") || host.endsWith(".local");
+  if (blocked) {
+    throw new Error(`remoteMcp.url for '${definitionId}' resolves to a disallowed (internal/link-local/metadata) host: ${host}`);
+  }
+}
+function renderRemoteMcpSpec(definitionId, spec) {
+  assertSafeRemoteMcpUrl(spec.url, definitionId);
+  const headers = {};
+  if (spec.auth) {
+    const envVar = credentialEnvVar(definitionId, spec.auth.credential_ref);
+    const value = `\${${envVar}}`;
+    if (spec.auth.scheme === "bearer") {
+      headers["Authorization"] = `Bearer ${value}`;
+    } else {
+      if (!spec.auth.header_name) {
+        throw new Error(`remoteMcp.auth for '${definitionId}' uses scheme 'header' but no header_name`);
+      }
+      headers[spec.auth.header_name] = value;
+    }
+  }
+  Object.assign(headers, spec.headers ?? {});
+  return {
+    type: spec.type ?? "http",
+    url: spec.url,
+    ...Object.keys(headers).length > 0 ? { headers } : {}
+  };
+}
+function buildRemoteMcpEntry(definitionId, dbSpec) {
+  const spec = dbSpec ?? INTEGRATION_REGISTRY.find((d) => d.id === definitionId)?.remoteMcp;
+  if (spec) {
+    return renderRemoteMcpSpec(definitionId, spec);
+  }
+  const provider = OAUTH_PROVIDERS[definitionId];
+  if (!provider?.mcpUrl)
+    return null;
+  return {
+    type: "http",
+    url: provider.mcpUrl,
+    headers: {
+      Authorization: `Bearer \${${envVarForToken(definitionId)}}`
+    }
+  };
+}
+function buildHostBrokeredRemoteMcpEntry(url) {
+  return { type: "http", url };
+}
+function extractHeaderVarName(value) {
+  const m = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(value.trim());
+  return m ? m[1] : null;
+}
+function buildLiveHeaderRemoteMcpProxyEntry(definitionId, dbSpec, paths) {
+  const spec = dbSpec ?? INTEGRATION_REGISTRY.find((d) => d.id === definitionId)?.remoteMcp;
+  if (!spec?.liveHeaderRefresh)
+    return null;
+  assertSafeRemoteMcpUrl(spec.url, definitionId);
+  if (!spec.auth || spec.auth.scheme !== "header" || !spec.auth.header_name) {
+    throw new Error(`remoteMcp.liveHeaderRefresh for '${definitionId}' requires a header-scheme 'auth' with a header_name`);
+  }
+  const extraPairs = [];
+  for (const [header, value] of Object.entries(spec.headers ?? {})) {
+    const varName = extractHeaderVarName(value);
+    if (varName)
+      extraPairs.push(`${header}:${varName}`);
+  }
+  return {
+    command: "node",
+    args: [paths.proxyPath],
+    env: {
+      AGT_REMOTE_MCP_URL: spec.url,
+      AGT_REMOTE_MCP_TOKEN_FILE: paths.tokenFile,
+      AGT_REMOTE_MCP_TOKEN_VAR: credentialEnvVar(definitionId, spec.auth.credential_ref),
+      AGT_REMOTE_MCP_AUTH_HEADER: spec.auth.header_name,
+      AGT_REMOTE_MCP_LABEL: definitionId,
+      ...extraPairs.length > 0 ? { AGT_REMOTE_MCP_EXTRA_HEADERS: extraPairs.join(",") } : {}
+    }
+  };
+}
+function buildOAuthRemoteMcpProxyEntry(definitionId, paths) {
+  const def = INTEGRATION_REGISTRY.find((d) => d.id === definitionId);
+  if (def?.remoteMcp)
+    return null;
+  const provider = OAUTH_PROVIDERS[definitionId];
+  if (!provider?.mcpUrl)
+    return null;
+  return {
+    command: "node",
+    args: [paths.proxyPath],
+    env: {
+      AGT_REMOTE_MCP_URL: provider.mcpUrl,
+      AGT_REMOTE_MCP_TOKEN_FILE: paths.tokenFile,
+      AGT_REMOTE_MCP_TOKEN_VAR: envVarForToken(definitionId),
+      AGT_REMOTE_MCP_LABEL: definitionId,
+      // ENG-6948: cap the agent's exposed surface to the curated allowlist. The
+      // proxy filters tools/list and gates tools/call against this set. Omitted
+      // when the provider has no allowlist, leaving the proxy a pass-through.
+      ...provider.toolAllowlist && provider.toolAllowlist.length > 0 ? { AGT_REMOTE_MCP_TOOL_ALLOWLIST: provider.toolAllowlist.join(",") } : {},
+      // CS-1446: toolsets to pre-activate at session start so gated tools are
+      // advertised in the connect-time tools/list the harness freezes. Omitted
+      // when the provider configures none (no pre-enable, the default).
+      ...provider.preEnableToolsets && provider.preEnableToolsets.length > 0 ? { AGT_REMOTE_MCP_PREENABLE_TOOLSETS: provider.preEnableToolsets.join(",") } : {}
+    }
+  };
+}
+
+// ../../packages/core/dist/provisioning/native-mcp.js
+function buildNativeMcpEntry(spec, ctx) {
+  const resolvedCommand = resolveTemplate(spec.command, ctx);
+  if (resolvedCommand.omit) {
+    throw new Error("NativeMcpSpec: empty_if_no_env is only valid in env values (not in `command`)");
+  }
+  const command = resolvedCommand.value;
+  const args = spec.args.map((a, i) => {
+    const resolved = resolveTemplate(a, ctx);
+    if (resolved.omit) {
+      throw new Error(`NativeMcpSpec: empty_if_no_env is only valid in env values (not in args[${i}])`);
+    }
+    return resolved.value;
+  });
+  if (spec.env === void 0) {
+    return { command, args };
+  }
+  const env2 = {};
+  for (const [k, raw] of Object.entries(spec.env)) {
+    const { value, omit } = resolveTemplate(raw, ctx);
+    if (omit)
+      continue;
+    env2[k] = value;
+  }
+  return { command, args, env: env2 };
+}
+function resolveTemplate(input, ctx) {
+  const TOKEN = /\{\{([^}]+)\}\}/g;
+  const hasEmptyIfNoEnv = /\{\{\s*empty_if_no_env\./.test(input);
+  const isWholeValueEmptyIfNoEnv = /^\{\{\s*empty_if_no_env\.[^}]+\}\}$/.test(input);
+  if (hasEmptyIfNoEnv && !isWholeValueEmptyIfNoEnv) {
+    throw new Error(`NativeMcpSpec: empty_if_no_env must be the sole content of the value, never mixed with literal text or other tokens (value: ${JSON.stringify(input)})`);
+  }
+  let omit = false;
+  const value = input.replace(TOKEN, (whole, expr) => {
+    const trimmed = expr.trim();
+    if (trimmed === "agent_id")
+      return ctx.agentId;
+    if (trimmed === "agent_code_name")
+      return ctx.agentCodeName;
+    if (trimmed === "integration_id")
+      return ctx.integration?.id ?? "";
+    if (trimmed.startsWith("process_env.")) {
+      const name = trimmed.slice("process_env.".length);
+      return process.env[name] ?? "";
+    }
+    if (trimmed.startsWith("empty_if_no_env.")) {
+      const name = trimmed.slice("empty_if_no_env.".length);
+      const v = process.env[name] ?? "";
+      if (v.length === 0) {
+        omit = true;
+        return "";
+      }
+      return v;
+    }
+    return whole;
+  });
+  return { value, omit };
+}
+
+// ../../packages/core/dist/provisioning/frameworks/opencode/integrations.js
+function toOpencodeEnvRefs(value) {
+  return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => `{env:${name}}`);
+}
+function envPrefix(definitionId) {
+  return definitionId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+}
+function remoteMcpCredentialEnvVar(definitionId, credentialRef) {
+  return `${envPrefix(definitionId)}_${credentialRef.replace(/-/g, "_").toUpperCase()}`;
+}
+function toOpencodeRemoteEntry(entry) {
+  const headers = entry.headers ? Object.fromEntries(Object.entries(entry.headers).map(([k, v]) => [k, toOpencodeEnvRefs(v)])) : void 0;
+  return {
+    type: "remote",
+    url: entry.url,
+    ...headers && Object.keys(headers).length > 0 ? { headers } : {},
+    enabled: true
+  };
+}
+function toOpencodeLocalEntry(entry) {
+  const environment = entry.env ? Object.fromEntries(Object.entries(entry.env).map(([k, v]) => [k, toOpencodeEnvRefs(v)])) : void 0;
+  return {
+    type: "local",
+    command: [entry.command, ...entry.args],
+    ...environment && Object.keys(environment).length > 0 ? { environment } : {},
+    enabled: true
+  };
+}
+function buildOpencodeIntegrationServers(integrations, ctx) {
+  const servers = {};
+  const envUpdates = {};
+  for (const integration of integrations) {
+    const prefix = envPrefix(integration.definition_id);
+    const creds = integration.credentials ?? {};
+    if (integration.auth_type === "oauth2" || integration.auth_type === "github_app") {
+      const token = creds.access_token;
+      if (typeof token === "string" && token)
+        envUpdates[`${prefix}_ACCESS_TOKEN`] = token;
+    } else if (integration.auth_type === "api_key") {
+      const token = creds.api_key;
+      if (typeof token === "string" && token)
+        envUpdates[`${prefix}_API_KEY`] = token;
+    }
+    const remoteSpec = integration.remoteMcp ?? INTEGRATION_REGISTRY.find((d) => d.id === integration.definition_id)?.remoteMcp;
+    if (remoteSpec?.auth) {
+      const ref = remoteSpec.auth.credential_ref;
+      const value = creds[ref];
+      if (typeof value === "string" && value) {
+        envUpdates[remoteMcpCredentialEnvVar(integration.definition_id, ref)] = value;
+      }
+    }
+    if (integration.config) {
+      for (const [key, value] of Object.entries(integration.config)) {
+        if (typeof value === "string" && value) {
+          const upper = key.toUpperCase();
+          const envKey = upper.startsWith(`${prefix}_`) ? upper : `${prefix}_${upper}`;
+          envUpdates[envKey] = value;
+        }
+      }
+    }
+  }
+  for (const integration of integrations) {
+    const defaults = integration.remoteMcp?.envDefaults ?? INTEGRATION_REGISTRY.find((d) => d.id === integration.definition_id)?.remoteMcp?.envDefaults;
+    if (!defaults)
+      continue;
+    for (const [key, value] of Object.entries(defaults)) {
+      if (!(key in envUpdates))
+        envUpdates[key] = value;
+    }
+  }
+  for (const integration of integrations) {
+    const def = INTEGRATION_REGISTRY.find((d) => d.id === integration.definition_id);
+    const remote = buildRemoteMcpEntry(integration.definition_id, integration.remoteMcp ?? null);
+    if (remote) {
+      servers[integration.definition_id] = toOpencodeRemoteEntry(remote);
+      continue;
+    }
+    if (def?.nativeMcp) {
+      const key = def.nativeMcp.key ?? integration.definition_id;
+      servers[key] = toOpencodeLocalEntry(buildNativeMcpEntry(def.nativeMcp, {
+        agentId: ctx.agentId,
+        agentCodeName: ctx.agentCodeName,
+        integration
+      }));
+    }
+  }
+  return { servers, envUpdates };
+}
+
 // ../../packages/core/dist/provisioning/frameworks/opencode/opencode-client.js
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var HttpOpencodeClient = class _HttpOpencodeClient {
@@ -9306,6 +9582,22 @@ function readEnvIntegrations(codeName) {
   }
   return out;
 }
+var INTEGRATION_KEYS_FILE = "integration-mcp-keys.json";
+function readIntegrationServerKeys(codeName) {
+  const p2 = join(agentDir(codeName), INTEGRATION_KEYS_FILE);
+  if (!existsSync2(p2))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync3(p2, "utf8"));
+    return Array.isArray(parsed) ? parsed.filter((k) => typeof k === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function writeIntegrationServerKeys(codeName, keys) {
+  mkdirSync(agentDir(codeName), { recursive: true });
+  writeFileSync2(join(agentDir(codeName), INTEGRATION_KEYS_FILE), JSON.stringify([...keys].sort(), null, 2));
+}
 var ENV_SUBSTITUTION = /^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/;
 function readChannelServerEnv(codeName, channelId) {
   const mcp = readConfig(codeName)["mcp"];
@@ -9407,6 +9699,50 @@ var opencodeAdapter = {
     cfg["mcp"] = mcp;
     writeConfig(codeName, cfg);
   },
+  /**
+   * ENG-7976: render org/team/agent-scoped integrations into opencode's `mcp`
+   * block. Follow-up to ENG-7959 - the adapter previously implemented no
+   * `writeIntegrations`, so the manager's `/host/agent-integrations` provisioning
+   * path was silently skipped for opencode and every integration MCP server
+   * (remote_mcp catalog + OAuth remotes + data-driven native) was dropped.
+   *
+   * The mapping is pure (`buildOpencodeIntegrationServers`, reusing the same
+   * shared builders as the claude-code adapter). Secrets never enter the
+   * drift-checked config: they are seeded into `.env.integrations` and referenced
+   * as `{env:VAR}`, resolved by the runtime materializer at serve spawn - the same
+   * contract `writeChannelCredentials` uses. Integration servers are merged INTO
+   * the existing `mcp` map (never a wholesale replace) so the generator's
+   * `augmented` entry and any channel servers already on disk survive.
+   *
+   * Stale integration servers (an integration disconnected since the last write)
+   * are pruned: any entry previously written by this method that is not in the
+   * fresh set is removed, while the `augmented` entry, channel servers and managed
+   * toolkit servers are left untouched.
+   */
+  writeIntegrations(codeName, integrations, agentId) {
+    const { servers, envUpdates } = buildOpencodeIntegrationServers(integrations, {
+      agentId: agentId ?? "",
+      agentCodeName: codeName
+    });
+    upsertEnvIntegrations(codeName, envUpdates);
+    const previous = readIntegrationServerKeys(codeName);
+    if (Object.keys(servers).length === 0 && previous.length === 0 && !existsSync2(configPath(codeName))) {
+      return;
+    }
+    const cfg = readConfig(codeName);
+    const mcp = cfg["mcp"] ?? {};
+    const fresh = new Set(Object.keys(servers));
+    for (const key of previous) {
+      if (!fresh.has(key))
+        delete mcp[key];
+    }
+    for (const [serverId, entry] of Object.entries(servers)) {
+      mcp[serverId] = entry;
+    }
+    cfg["mcp"] = mcp;
+    writeConfig(codeName, cfg);
+    writeIntegrationServerKeys(codeName, Object.keys(servers));
+  },
   removeMcpServer(codeName, serverId) {
     const cfg = readConfig(codeName);
     const mcp = cfg["mcp"];
@@ -9853,6 +10189,12 @@ async function spawnServe(config, session) {
   mkdirSync3(join3(homedir3(), ".augmented", codeName), { recursive: true });
   const serveEnv = {
     ...process.env,
+    // ENG-7976: integration + channel credential secrets so the adapter's
+    // `{env:VAR}` refs (remote MCP auth headers, native MCP env, channel tokens)
+    // resolve at materialization. Layered after process.env (so the file supplies
+    // creds absent from the host env) and before the per-agent provider key +
+    // manager runtime env (which win for their own keys).
+    ...readAgentIntegrationsEnv(codeName),
     ...readAgentProviderEnv(codeName),
     ...stripUndefined(config.serveEnv ?? {}),
     OPENCODE_SERVER_PASSWORD: password,
@@ -9991,6 +10333,42 @@ function readAgentProviderEnv(codeName, dir) {
   }
   return out;
 }
+var INTEGRATIONS_ENV_BLOCKLIST = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "SHELL",
+  "IFS",
+  "ENV",
+  "BASH_ENV",
+  "NODE_OPTIONS",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH"
+]);
+function readAgentIntegrationsEnv(codeName, dir) {
+  const file = join3(dir ?? join3(homedir3(), ".augmented", codeName), ".env.integrations");
+  const out = {};
+  try {
+    if (!existsSync4(file)) return out;
+    for (const raw of readFileSync5(file, "utf-8").split("\n")) {
+      const line2 = raw.trim();
+      if (!line2 || line2.startsWith("#")) continue;
+      const eq = line2.indexOf("=");
+      if (eq <= 0) continue;
+      const key = line2.slice(0, eq).trim();
+      if (INTEGRATIONS_ENV_BLOCKLIST.has(key)) continue;
+      let val = line2.slice(eq + 1).trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.slice(1, -1);
+      }
+      out[key] = val;
+    }
+  } catch {
+  }
+  return out;
+}
 
 // src/lib/persistent-session.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -11620,6 +11998,11 @@ export {
   INTEGRATION_REGISTRY,
   getIntegration,
   OAUTH_PROVIDERS,
+  buildRemoteMcpEntry,
+  buildHostBrokeredRemoteMcpEntry,
+  buildLiveHeaderRemoteMcpProxyEntry,
+  buildOAuthRemoteMcpProxyEntry,
+  buildNativeMcpEntry,
   toOpencodeModel,
   mergeOpencodeConfigArtifact,
   readChannelServerEnv,
@@ -11753,4 +12136,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-RIWZIYJ7.js.map
+//# sourceMappingURL=chunk-NDF3YMP5.js.map