@gakim-digital/dexter-bridge 0.5.21 → 0.11.0

package/src/runtimeProfiles.js

@@ -0,0 +1,284 @@
+import crypto from 'node:crypto';
+import { createLocalAgentAdapter } from './providers/index.js';
+
+const DRIVER_LABELS = {
+  'codex-app-server': 'Codex',
+  'claude-code-cli': 'Claude Code',
+  'direct-byok': 'Local API key',
+  opencode: 'OpenCode',
+  acp: 'ACP agent',
+};
+
+export const APP_BUILDER_RUNTIME_SELECTIONS = ['codex', 'claude-code', 'opencode'];
+
+export function normalizeRuntimeSelection(value) {
+  const normalized = text(value, 80).toLowerCase();
+  return APP_BUILDER_RUNTIME_SELECTIONS.includes(normalized) ? normalized : null;
+}
+
+export function runtimeDriver(selection) {
+  if (selection === 'codex') return 'codex-app-server';
+  if (selection === 'claude-code') return 'claude-code-cli';
+  if (selection === 'opencode') return 'opencode';
+  return null;
+}
+
+function text(value, maximum = 4096) {
+  return typeof value === 'string' && value.trim() ? value.trim().slice(0, maximum) : '';
+}
+
+function stableIdentity(driver, instanceId) {
+  return crypto.createHash('sha256').update(`${driver}\0${instanceId}`).digest('hex').slice(0, 32);
+}
+
+function normalizeCapabilities(value = {}) {
+  return {
+    tools: value.tools !== false,
+    vision: value.vision === true,
+    structuredOutput: value.structuredOutput !== false,
+    sessionResume: value.sessionResume !== false,
+    outcomeExecution: value.outcomeExecution === true,
+    workspaceSnapshot: value.workspaceSnapshot === true,
+    workspaceWrite: value.workspaceWrite === true,
+    shell: value.shell === true,
+    projectShell: value.projectShell === true,
+    preview: value.preview === true,
+    browser: value.browser === true,
+    dataInspection: value.dataInspection === true,
+    verification: value.verification === true,
+    standardTools: value.standardTools === true,
+    progress: value.progress !== false,
+    cancellation: value.cancellation !== false,
+  };
+}
+
+export function normalizeRuntimeProfile(value, { includeSecret = false } = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const driver = text(value.driver, 80);
+  const instanceId = text(value.instanceId || value.id, 160);
+  if (!driver || !instanceId) return null;
+  const id = text(value.id, 180) || `${driver}:${instanceId}`;
+  const models = (Array.isArray(value.models) ? value.models : []).slice(0, 100).flatMap((model) => {
+    if (!model || typeof model !== 'object' || Array.isArray(model)) return [];
+    const modelId = text(model.id, 255);
+    if (!modelId) return [];
+    return [
+      {
+        id: modelId,
+        provider: text(model.provider, 80) || text(value.providerId, 80) || driver,
+        displayName: text(model.displayName, 160) || modelId,
+        invocationName: text(model.invocationName, 255) || modelId,
+        costTier: ['$', '$$', '$$$'].includes(model.costTier) ? model.costTier : '$$',
+        description: text(model.description, 500),
+        capabilities: normalizeCapabilities(model.capabilities || value.capabilities),
+      },
+    ];
+  });
+  const profile = {
+    id,
+    instanceId,
+    label: text(value.label, 160) || DRIVER_LABELS[driver] || driver,
+    location: 'local',
+    driver,
+    providerId: text(value.providerId, 80) || driver,
+    authState: ['ready', 'required', 'error'].includes(value.authState) ? value.authState : 'ready',
+    continuationIdentity: text(value.continuationIdentity, 180) || stableIdentity(driver, instanceId),
+    capabilities: normalizeCapabilities(value.capabilities),
+    models,
+    ...(text(value.keyLast4, 16) ? { keyLast4: text(value.keyLast4, 16) } : {}),
+    ...(text(value.command, 2048) ? { command: text(value.command, 2048) } : {}),
+    ...(Array.isArray(value.args)
+      ? {
+          args: value.args
+            .map((item) => text(item, 1024))
+            .filter(Boolean)
+            .slice(0, 40),
+        }
+      : {}),
+    ...(text(value.cwd, 2048) ? { cwd: text(value.cwd, 2048) } : {}),
+  };
+  if (includeSecret && value.credentials) profile.credentials = value.credentials;
+  return profile;
+}
+
+export function publicRuntimeProfile(value) {
+  const profile = normalizeRuntimeProfile(value);
+  if (!profile) return null;
+  const { credentials: _credentials, command: _command, args: _args, cwd: _cwd, ...publicProfile } = profile;
+  return publicProfile;
+}
+
+function profileFromAgentCheck(check) {
+  if (!check || check.installed === false) return null;
+  const driver =
+    check.agent === 'codex' ? 'codex-app-server' : check.agent === 'claude-code' ? 'claude-code-cli' : null;
+  if (!driver) return null;
+  const codexProviderId = check.agent === 'codex' ? text(check.providerId, 80) || 'openai' : null;
+  const codexProviderName = check.agent === 'codex' ? text(check.providerName, 160) : '';
+  return normalizeRuntimeProfile({
+    id: `${check.agent}:default`,
+    instanceId: 'default',
+    label:
+      codexProviderName && (codexProviderId !== 'openai' || check.fallbackProviderUsed)
+        ? `Codex · ${codexProviderName}${check.fallbackProviderUsed ? ' fallback' : ''}`
+        : DRIVER_LABELS[driver],
+    driver,
+    providerId: check.agent === 'codex' ? codexProviderId : 'anthropic',
+    authState: check.signedIn === false ? 'required' : 'ready',
+    capabilities: {
+      tools: true,
+      vision: true,
+      structuredOutput: true,
+      sessionResume: true,
+      outcomeExecution: true,
+      workspaceSnapshot: true,
+      workspaceWrite: true,
+      shell: true,
+      projectShell: true,
+      preview: true,
+      browser: true,
+      dataInspection: true,
+      verification: true,
+      standardTools: true,
+      progress: true,
+      cancellation: true,
+    },
+    models: check.modelDetails || [],
+  });
+}
+
+function localByokProfiles(config) {
+  return (Array.isArray(config?.localCredentials) ? config.localCredentials : []).flatMap((credential) => {
+    const provider = text(credential?.provider, 80).toLowerCase();
+    const model = text(credential?.model, 255);
+    const instanceId = text(credential?.id, 160);
+    if (!provider || !model || !instanceId || !text(credential?.apiKey, 8192)) return [];
+    const profile = normalizeRuntimeProfile(
+      {
+        id: `local-byok:${instanceId}`,
+        instanceId,
+        label: text(credential.label, 160) || `${provider} local key`,
+        driver: 'direct-byok',
+        providerId: provider,
+        continuationIdentity: text(credential.continuationIdentity, 180) || stableIdentity('direct-byok', instanceId),
+        keyLast4: text(credential.apiKey, 8192).slice(-4),
+        capabilities: {
+          tools: true,
+          vision: true,
+          structuredOutput: true,
+          sessionResume: false,
+        },
+        models: [
+          {
+            id: `local-byok:${instanceId}:${model}`,
+            provider,
+            displayName: model,
+            invocationName: model,
+            costTier: '$$',
+            description: `${provider} model using a key stored on this computer.`,
+          },
+        ],
+        credentials: {
+          provider,
+          apiKey: credential.apiKey,
+          model,
+          ...(text(credential.baseURL, 2048) ? { baseURL: text(credential.baseURL, 2048) } : {}),
+        },
+      },
+      { includeSecret: true },
+    );
+    return profile ? [profile] : [];
+  });
+}
+
+function configuredAcpProfiles(config) {
+  return (Array.isArray(config?.acpProfiles) ? config.acpProfiles : [])
+    .map((profile) =>
+      normalizeRuntimeProfile({
+        ...profile,
+        id: text(profile?.id, 180) || `acp:${crypto.randomUUID()}`,
+        driver: 'acp',
+        providerId: text(profile?.providerId, 80) || 'acp',
+      }),
+    )
+    .filter(Boolean);
+}
+
+export async function discoverRuntimeProfiles({
+  agentChecks = [],
+  config = {},
+  env = process.env,
+  trace,
+  runtimeSelection,
+} = {}) {
+  const selectedRuntime = normalizeRuntimeSelection(runtimeSelection);
+  const selectedDriver = runtimeDriver(selectedRuntime);
+  const profiles = agentChecks
+    .map(profileFromAgentCheck)
+    .filter(Boolean)
+    .filter((profile) => !selectedDriver || profile.driver === selectedDriver);
+  if (!selectedRuntime) {
+    profiles.push(...localByokProfiles(config));
+    profiles.push(...configuredAcpProfiles(config));
+  }
+
+  if (
+    (!selectedRuntime || selectedRuntime === 'opencode') &&
+    String(env.DEXTER_BRIDGE_OPENCODE_ENABLED || 'true').toLowerCase() !== 'false'
+  ) {
+    const profile = normalizeRuntimeProfile({
+      id: 'opencode:default',
+      instanceId: 'default',
+      label: 'OpenCode',
+      driver: 'opencode',
+      providerId: 'opencode',
+      command: env.DEXTER_BRIDGE_OPENCODE_BIN || 'opencode',
+      capabilities: {
+        tools: true,
+        vision: true,
+        structuredOutput: true,
+        sessionResume: true,
+        outcomeExecution: true,
+        workspaceSnapshot: true,
+        workspaceWrite: true,
+        shell: true,
+        projectShell: true,
+        preview: true,
+        browser: true,
+        dataInspection: true,
+        verification: true,
+        standardTools: true,
+        progress: true,
+        cancellation: true,
+      },
+      models: [],
+    });
+    const adapter = createLocalAgentAdapter(profile, { env, trace });
+    try {
+      const status = await adapter.detect();
+      if (status.ok) {
+        const models = await adapter.models().catch(() => []);
+        profiles.push(
+          normalizeRuntimeProfile({
+            ...profile,
+            authState: status.signedIn === false ? 'required' : 'ready',
+            models,
+          }),
+        );
+      }
+    } finally {
+      adapter?.close?.();
+    }
+  }
+
+  return profiles.filter(Boolean).filter((profile) => !selectedDriver || profile.driver === selectedDriver);
+}
+
+export function runtimeProfileMap(profiles = []) {
+  return new Map(
+    profiles
+      .map((profile) => normalizeRuntimeProfile(profile, { includeSecret: true }))
+      .filter(Boolean)
+      .map((profile) => [profile.id, profile]),
+  );
+}