@amalgm/chat 0.1.2 → 0.2.0

package/host/adapters/prompt.js

@@ -0,0 +1,212 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export class UnsupportedPromptPartError extends Error {
+  constructor(adapterId, index, part, reason) {
+    super(`${adapterId} cannot accept prompt.parts[${index}] (${part.type}): ${reason}`);
+    this.name = 'UnsupportedPromptPartError';
+    this.code = 'UNSUPPORTED_PROMPT_PART';
+    this.adapterId = adapterId;
+    this.partIndex = index;
+    this.partType = part.type;
+  }
+}
+
+function dataUrl(mimeType, data) {
+  return `data:${mimeType};base64,${data}`;
+}
+
+function resourceName(part) {
+  if (part.name) return part.name;
+  const uri = part.resource?.uri || part.uri || '';
+  try {
+    const parsed = new URL(uri);
+    return path.basename(decodeURIComponent(parsed.pathname)) || parsed.hostname || uri;
+  } catch {
+    return uri || 'attachment';
+  }
+}
+
+function linkedText(part) {
+  return `[Attachment: ${resourceName(part)}](${part.uri})`;
+}
+
+function embeddedText(part) {
+  const resource = part.resource;
+  return `<attachment uri=${JSON.stringify(resource.uri)}\n>${resource.text}</attachment>`;
+}
+
+function localPath(uri) {
+  if (!String(uri).startsWith('file:')) return null;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}
+
+function mimeOf(part) {
+  return part.mimeType || part.resource?.mimeType || 'application/octet-stream';
+}
+
+function textProjection(part) {
+  if (part.type === 'text') return part.text;
+  if (part.type === 'resource_link') return linkedText(part);
+  if (part.type === 'resource' && typeof part.resource.text === 'string') return embeddedText(part);
+  return null;
+}
+
+export function acpPromptParts(prompt, preamble = '') {
+  const parts = prompt.parts.map((part) => structuredClone(part));
+  return preamble ? [{ type: 'text', text: preamble }, ...parts] : parts;
+}
+
+export function codexPromptInput(prompt) {
+  return prompt.parts.flatMap((part, index) => {
+    if (part.type === 'text') return [{ type: 'text', text: part.text }];
+    if (part.type === 'image') {
+      return [{ type: 'image', url: dataUrl(part.mimeType, part.data) }];
+    }
+    if (part.type === 'audio') {
+      return [{ type: 'audio', url: dataUrl(part.mimeType, part.data) }];
+    }
+    if (part.type === 'resource_link') {
+      const file = localPath(part.uri);
+      const mime = mimeOf(part);
+      if (!file && mime.startsWith('image/')) return [{ type: 'image', url: part.uri }];
+      if (!file && mime.startsWith('audio/')) return [{ type: 'audio', url: part.uri }];
+      if (!file) return [{ type: 'text', text: linkedText(part) }];
+      if (mime.startsWith('image/')) return [{ type: 'localImage', path: file }];
+      if (mime.startsWith('audio/')) return [{ type: 'localAudio', path: file }];
+      return [{ type: 'mention', name: resourceName(part), path: file }];
+    }
+    if (part.type === 'resource') {
+      const mime = mimeOf(part);
+      if (mime.startsWith('image/')) {
+        return [{ type: 'image', url: dataUrl(mime, part.resource.blob) }];
+      }
+      if (mime.startsWith('audio/')) {
+        return [{ type: 'audio', url: dataUrl(mime, part.resource.blob) }];
+      }
+      throw new UnsupportedPromptPartError('codex', index, part, `embedded ${mime} is not a Codex input type`);
+    }
+    throw new UnsupportedPromptPartError('codex', index, part, 'unknown content type');
+  });
+}
+
+function claudeContent(prompt) {
+  return prompt.parts.map((part, index) => {
+    if (part.type === 'text') return { type: 'text', text: part.text };
+    if (part.type === 'image') {
+      if (!['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(part.mimeType)) {
+        throw new UnsupportedPromptPartError('claude_code', index, part, `image type ${part.mimeType} is not supported`);
+      }
+      return { type: 'image', source: { type: 'base64', media_type: part.mimeType, data: part.data } };
+    }
+    if (part.type === 'audio') {
+      throw new UnsupportedPromptPartError('claude_code', index, part, 'Claude Code has no audio input block');
+    }
+    if (part.type === 'resource_link') {
+      const mime = mimeOf(part);
+      if (!localPath(part.uri) && ['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(mime)) {
+        return { type: 'image', source: { type: 'url', url: part.uri } };
+      }
+      if (!localPath(part.uri) && mime === 'application/pdf') {
+        return { type: 'document', source: { type: 'url', url: part.uri }, title: resourceName(part) };
+      }
+      return { type: 'text', text: linkedText(part) };
+    }
+    if (part.type === 'resource') {
+      if (typeof part.resource.text === 'string') {
+        return {
+          type: 'document',
+          source: { type: 'text', media_type: 'text/plain', data: part.resource.text },
+          title: resourceName(part),
+        };
+      }
+      const mime = mimeOf(part);
+      if (mime === 'application/pdf') {
+        return { type: 'document', source: { type: 'base64', media_type: mime, data: part.resource.blob } };
+      }
+      if (mime.startsWith('image/')) {
+        if (!['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(mime)) {
+          throw new UnsupportedPromptPartError('claude_code', index, part, `image type ${mime} is not supported`);
+        }
+        return { type: 'image', source: { type: 'base64', media_type: mime, data: part.resource.blob } };
+      }
+      throw new UnsupportedPromptPartError('claude_code', index, part, `embedded ${mime} is not a Claude input block`);
+    }
+    throw new UnsupportedPromptPartError('claude_code', index, part, 'unknown content type');
+  });
+}
+
+export function claudePrompt(prompt) {
+  if (prompt.parts.every((part) => part.type === 'text')) {
+    return prompt.parts.map((part) => part.text).join('\n\n');
+  }
+  const content = claudeContent(prompt);
+  return (async function* messages() {
+    yield {
+      type: 'user',
+      message: { role: 'user', content },
+      parent_tool_use_id: null,
+    };
+  }());
+}
+
+export function openCodePromptParts(prompt) {
+  return prompt.parts.map((part) => {
+    if (part.type === 'text') return { type: 'text', text: part.text };
+    if (part.type === 'resource_link') {
+      return {
+        type: 'file',
+        mime: mimeOf(part),
+        filename: resourceName(part),
+        url: part.uri,
+      };
+    }
+    if (part.type === 'image' || part.type === 'audio') {
+      return {
+        type: 'file',
+        mime: part.mimeType,
+        url: dataUrl(part.mimeType, part.data),
+      };
+    }
+    const resource = part.resource;
+    const mime = mimeOf(part);
+    const data = typeof resource.text === 'string'
+      ? Buffer.from(resource.text, 'utf8').toString('base64')
+      : resource.blob;
+    return {
+      type: 'file',
+      mime,
+      filename: resourceName(part),
+      url: dataUrl(mime, data),
+    };
+  });
+}
+
+export function piPrompt(prompt) {
+  const messages = [];
+  const images = [];
+  for (const [index, part] of prompt.parts.entries()) {
+    const text = textProjection(part);
+    if (text !== null) {
+      messages.push(text);
+      continue;
+    }
+    if (part.type === 'image') {
+      images.push({ type: 'image', data: part.data, mimeType: part.mimeType });
+      continue;
+    }
+    if (part.type === 'resource') {
+      const mime = mimeOf(part);
+      if (mime.startsWith('image/')) {
+        images.push({ type: 'image', data: part.resource.blob, mimeType: mime });
+        continue;
+      }
+    }
+    throw new UnsupportedPromptPartError('pi', index, part, 'Pi RPC accepts text and images');
+  }
+  return { message: messages.join('\n\n'), images };
+}

package/host/auth.js

@@ -0,0 +1,257 @@
+/** Native credential resolution and the scrubbed process environment. */
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveCredential } from './credentials/store.js';
+
+const AUTH_METHODS = Object.freeze({
+  claude_code: Object.freeze(['amalgm', 'byok', 'provider_auth']),
+  codex: Object.freeze(['amalgm', 'byok', 'provider_auth']),
+  cursor: Object.freeze(['provider_auth', 'byok']),
+  opencode: Object.freeze(['amalgm', 'byok', 'provider_auth']),
+  pi: Object.freeze(['amalgm', 'byok', 'provider_auth']),
+});
+
+function shellValue(raw) {
+  const value = String(raw ?? '').trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function readByokFile(amalgmDir) {
+  const out = {};
+  try {
+    const raw = fs.readFileSync(path.join(amalgmDir, '.amalgm-credentials'), 'utf8');
+    for (const line of raw.split(/\r?\n/)) {
+      const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+      if (match) out[match[1]] = shellValue(match[2]);
+    }
+  } catch {}
+  return out;
+}
+
+function byokKeyFor(harness, values) {
+  if (harness === 'claude_code') return values.ANTHROPIC_API_KEY || '';
+  if (harness === 'codex') return values.OPENAI_API_KEY || values.CODEX_API_KEY || '';
+  if (harness === 'cursor') return values.CURSOR_API_KEY || '';
+  if (harness === 'pi') return values.AI_GATEWAY_API_KEY || '';
+  return '';
+}
+
+function providerKindForModel(modelId) {
+  const provider = String(modelId || '').split('/')[0];
+  if (provider === 'anthropic') return 'anthropic_compatible';
+  if (provider === 'openai') return 'openai_compatible';
+  return provider ? 'ai_gateway' : null;
+}
+
+function resolveByokCredential(amalgmDir, { credentialId, harness, modelId }) {
+  if (credentialId) {
+    const credential = resolveCredential(amalgmDir, { credentialId, harness });
+    if (!credential) throw new Error(`BYOK credential not found: ${credentialId}`);
+    return credential;
+  }
+  const preferred = harness === 'cursor' ? 'cursor_api' : providerKindForModel(modelId);
+  if (preferred) {
+    const credential = resolveCredential(amalgmDir, { harness, providerKind: preferred });
+    if (credential) return credential;
+    if (preferred === 'ai_gateway') return null;
+  }
+  if ((harness === 'opencode' || harness === 'pi') && preferred !== 'ai_gateway') {
+    const gatewayCredential = resolveCredential(amalgmDir, { harness, providerKind: 'ai_gateway' });
+    if (gatewayCredential) return gatewayCredential;
+  }
+  return resolveCredential(amalgmDir, { harness });
+}
+
+export function fingerprint(value) {
+  return value ? crypto.createHash('sha256').update(String(value)).digest('hex').slice(0, 16) : null;
+}
+
+function safePathSegment(value) {
+  const clean = String(value || '').trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  return clean || 'default';
+}
+
+function findStableJsonIdentity(value, depth = 0) {
+  if (!value || typeof value !== 'object' || depth > 4) return null;
+  const keys = ['account_id', 'accountId', 'user_id', 'userId', 'email', 'login', 'username', 'sub'];
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === 'string' && candidate.trim()) return `${key}:${candidate.trim()}`;
+  }
+  for (const child of Object.values(value)) {
+    const found = findStableJsonIdentity(child, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+function readJsonIdentity(file) {
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    return findStableJsonIdentity(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+
+function providerAuthIdentity(harness) {
+  if (harness === 'codex') {
+    return readJsonIdentity(path.join(os.homedir(), '.codex', 'auth.json')) || 'codex:provider-default';
+  }
+  if (harness === 'claude_code') {
+    return readJsonIdentity(path.join(os.homedir(), '.claude.json'))
+      || readJsonIdentity(path.join(os.homedir(), '.claude', 'auth.json'))
+      || 'claude_code:provider-default';
+  }
+  return `${harness || 'provider'}:provider-default`;
+}
+
+function runtimeHome({ runtimeHomeRoot, harness, agentConfigId }) {
+  const harnessHome = path.join(runtimeHomeRoot, safePathSegment(harness));
+  return path.join(
+    harnessHome,
+    'agents',
+    safePathSegment(agentConfigId || harness),
+    'home',
+  );
+}
+
+function providerAuthFingerprint(harness) {
+  return fingerprint(providerAuthIdentity(harness));
+}
+
+export function authEnvelope({
+  harness,
+  authMethod,
+  sessionId,
+  localBaseUrl,
+  proxyBaseUrl,
+  amalgmDir,
+  runtimeHomeRoot = path.join(amalgmDir, 'cli-homes'),
+  credentialId,
+  modelId,
+  agentConfigId,
+}) {
+  const supported = AUTH_METHODS[harness];
+  if (supported && !supported.includes(authMethod)) {
+    throw new Error(`${harness} does not support ${authMethod} auth`);
+  }
+  const method = authMethod;
+  const byok = readByokFile(amalgmDir);
+  let baseUrl = null;
+  let forwardBaseUrl = null;
+  let tokenRef = null;
+  let tokenFingerprint = null;
+  let credential = null;
+  if (method === 'amalgm') {
+    if (!localBaseUrl || !proxyBaseUrl) {
+      throw new Error('Platform auth requires localBaseUrl and proxyBaseUrl');
+    }
+    const providerPath = harness === 'claude_code'
+      ? '/anthropic'
+      : harness === 'opencode'
+        ? '/ai_gateway/v3/ai'
+        // Pi's provider client appends its own API paths (/v1/messages or
+        // /v1/chat/completions), which the proxy serves under /ai_gateway.
+        : harness === 'pi'
+          ? '/ai_gateway'
+          : '/openai/v1';
+    forwardBaseUrl = `${String(proxyBaseUrl || '').replace(/\/$/, '')}${providerPath}`;
+    baseUrl = `${String(localBaseUrl).replace(/\/$/, '')}/chat/egress/${encodeURIComponent(sessionId)}${providerPath}`;
+    tokenRef = `session-local-${sessionId}`;
+    tokenFingerprint = fingerprint(tokenRef);
+  } else if (method === 'byok') {
+    credential = resolveByokCredential(amalgmDir, { credentialId, harness, modelId });
+    tokenRef = credential?.key || byokKeyFor(harness, byok);
+    if (!tokenRef) {
+      throw new Error(`No BYOK credential configured for ${harness}`);
+    }
+    tokenFingerprint = fingerprint(tokenRef);
+    baseUrl = credential?.baseUrl || (
+      harness === 'claude_code'
+        ? 'https://api.anthropic.com'
+        : harness === 'cursor'
+          ? null
+          : harness === 'pi'
+            ? 'https://ai-gateway.vercel.sh'
+            : 'https://api.openai.com/v1'
+    );
+  } else if (method === 'provider_auth') {
+    tokenFingerprint = providerAuthFingerprint(harness);
+  }
+  const runtimeHomePath = runtimeHome({ runtimeHomeRoot, harness, agentConfigId });
+  return {
+    method,
+    baseUrl,
+    credentialId: credential?.id || credentialId || null,
+    credentialName: credential?.name || null,
+    providerKind: credential?.providerKind || null,
+    forwardBaseUrl,
+    tokenRef,
+    tokenFingerprint,
+    runtimeHome: runtimeHomePath,
+  };
+}
+
+function safeBaseEnv(baseEnv = process.env) {
+  const env = {};
+  for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR']) {
+    if (baseEnv[key]) env[key] = baseEnv[key];
+  }
+  return env;
+}
+
+export function runtimeEnv(contract, baseEnv = process.env) {
+  const env = contract.authMethod === 'provider_auth' ? { ...baseEnv } : safeBaseEnv(baseEnv);
+  for (const key of ['OPENAI_API_KEY', 'OPENAI_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'AI_GATEWAY_API_KEY', 'AI_GATEWAY_BASE_URL', 'CURSOR_API_KEY', 'CURSOR_AUTH_TOKEN']) {
+    delete env[key];
+  }
+  if (contract.auth.runtimeHome) {
+    fs.mkdirSync(contract.auth.runtimeHome, { recursive: true });
+    env.HOME = contract.auth.runtimeHome;
+    env.CODEX_HOME = contract.auth.runtimeHome;
+    env.CLAUDE_CONFIG_DIR = contract.auth.runtimeHome;
+    env.OPENCODE_HOME = contract.auth.runtimeHome;
+    env.OPENCODE_CONFIG_DIR = contract.auth.runtimeHome;
+    if (contract.harness === 'opencode') {
+      env.XDG_CONFIG_HOME = path.join(contract.auth.runtimeHome, '.config');
+      env.XDG_DATA_HOME = path.join(contract.auth.runtimeHome, '.local', 'share');
+      env.XDG_STATE_HOME = path.join(contract.auth.runtimeHome, '.local', 'state');
+      env.XDG_CACHE_HOME = path.join(contract.auth.runtimeHome, '.cache');
+    }
+    if (contract.harness === 'claude_code' && contract.authMethod === 'provider_auth') {
+      delete env.CLAUDE_CONFIG_DIR;
+    }
+  }
+  env.IS_SANDBOX = '1';
+  if (baseEnv.AMALGM_RUNTIME_TOKEN) env.AMALGM_RUNTIME_TOKEN = baseEnv.AMALGM_RUNTIME_TOKEN;
+  if (contract.authMethod === 'amalgm' || contract.authMethod === 'byok') {
+    if (contract.harness === 'claude_code') {
+      if (contract.authMethod === 'amalgm') {
+        env.ANTHROPIC_AUTH_TOKEN = contract.auth.tokenRef || '';
+      } else {
+        env.ANTHROPIC_API_KEY = contract.auth.tokenRef || '';
+      }
+      if (contract.auth.baseUrl) env.ANTHROPIC_BASE_URL = contract.auth.baseUrl;
+    } else if (contract.harness === 'cursor') {
+      env.CURSOR_API_KEY = contract.auth.tokenRef || '';
+    } else if (contract.harness === 'opencode') {
+      env.AI_GATEWAY_API_KEY = contract.auth.tokenRef || '';
+      if (contract.auth.baseUrl) env.AI_GATEWAY_BASE_URL = contract.auth.baseUrl;
+    } else if (contract.harness === 'pi') {
+      // Pi keys the vercel-ai-gateway provider on this env var; base-URL
+      // overrides ride through the generated egress extension instead.
+      env.AI_GATEWAY_API_KEY = contract.auth.tokenRef || '';
+    } else {
+      env.OPENAI_API_KEY = contract.auth.tokenRef || '';
+      if (contract.auth.baseUrl) env.OPENAI_BASE_URL = contract.auth.baseUrl;
+    }
+  }
+  return env;
+}

package/host/credentials/store.js

@@ -0,0 +1,209 @@
+/**
+ * BYOK credential vault using AES-256-GCM with a key derived from a machine
+ * secret via scrypt.
+ */
+
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { amalgmDir as resolveAmalgmDir } from '../lib/runtime-paths.js';
+
+const STORE_VERSION = 1;
+const CIPHER = 'aes-256-gcm';
+const KEY_BYTES = 32;
+const SALT_BYTES = 16;
+const IV_BYTES = 12;
+
+export const DEFAULT_BASE_URL_BY_PROVIDER = {
+  anthropic_compatible: 'https://api.anthropic.com',
+  openai_compatible: 'https://api.openai.com/v1',
+  ai_gateway: 'https://ai-gateway.vercel.sh/v1',
+  cursor_api: '',
+};
+
+export function credentialsPath(amalgmDir) {
+  return path.join(amalgmDir || resolveAmalgmDir(), '.credentials');
+}
+
+function machineSecret() {
+  const pieces = [
+    os.hostname(),
+    os.userInfo().username,
+    os.homedir(),
+    process.platform,
+  ];
+  return pieces.filter(Boolean).join(':');
+}
+
+function deriveKey(salt) {
+  return crypto.scryptSync(machineSecret(), salt, KEY_BYTES);
+}
+
+function encryptSecret(plaintext) {
+  const salt = crypto.randomBytes(SALT_BYTES);
+  const iv = crypto.randomBytes(IV_BYTES);
+  const cipher = crypto.createCipheriv(CIPHER, deriveKey(salt), iv);
+  const data = Buffer.concat([cipher.update(String(plaintext), 'utf8'), cipher.final()]);
+  return {
+    alg: CIPHER,
+    salt: salt.toString('base64url'),
+    iv: iv.toString('base64url'),
+    tag: cipher.getAuthTag().toString('base64url'),
+    data: data.toString('base64url'),
+  };
+}
+
+function decryptSecret(encrypted) {
+  if (!encrypted || encrypted.alg !== CIPHER) throw new Error('Unsupported credential encryption format');
+  const salt = Buffer.from(encrypted.salt, 'base64url');
+  const iv = Buffer.from(encrypted.iv, 'base64url');
+  const tag = Buffer.from(encrypted.tag, 'base64url');
+  const data = Buffer.from(encrypted.data, 'base64url');
+  const decipher = crypto.createDecipheriv(CIPHER, deriveKey(salt), iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(data), decipher.final()]).toString('utf8');
+}
+
+function idFor() {
+  return `cred_${crypto.randomUUID().replace(/-/g, '').slice(0, 18)}`;
+}
+
+function keyHint(key) {
+  const clean = String(key || '').trim();
+  return clean ? `...${clean.slice(-4)}` : null;
+}
+
+function keyFingerprint(key) {
+  const clean = String(key || '').trim();
+  return clean ? crypto.createHash('sha256').update(clean).digest('hex').slice(0, 16) : null;
+}
+
+export function normalizeBaseUrl(baseUrl, providerKind) {
+  const fallback = Object.prototype.hasOwnProperty.call(DEFAULT_BASE_URL_BY_PROVIDER, providerKind)
+    ? DEFAULT_BASE_URL_BY_PROVIDER[providerKind]
+    : DEFAULT_BASE_URL_BY_PROVIDER.openai_compatible;
+  const raw = String(baseUrl || fallback).trim();
+  return raw.replace(/\/+$/, '');
+}
+
+export function inferProviderKind({ baseUrl, key }) {
+  const url = String(baseUrl || '').toLowerCase();
+  const token = String(key || '').trim();
+  if (url.includes('anthropic') || token.startsWith('sk-ant-')) return 'anthropic_compatible';
+  if (url.includes('ai-gateway.vercel') || url.includes('gateway.vercel') || token.startsWith('v0_')) return 'ai_gateway';
+  return 'openai_compatible';
+}
+
+function sanitizeCredential(record) {
+  return {
+    id: record.id,
+    name: record.name,
+    providerKind: record.providerKind,
+    keyHint: record.keyHint || null,
+    tokenFingerprint: record.tokenFingerprint || null,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+  };
+}
+
+function emptyStore() {
+  return { version: STORE_VERSION, credentials: [] };
+}
+
+function readStore(amalgmDir) {
+  const file = credentialsPath(amalgmDir);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!parsed || typeof parsed !== 'object') return emptyStore();
+    if (!Array.isArray(parsed.credentials)) return emptyStore();
+    return {
+      version: parsed.version || STORE_VERSION,
+      credentials: parsed.credentials,
+    };
+  } catch {
+    return emptyStore();
+  }
+}
+
+function writeStore(amalgmDir, store) {
+  const file = credentialsPath(amalgmDir);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+  try { fs.chmodSync(file, 0o600); } catch {}
+}
+
+export function listCredentials(amalgmDir) {
+  return readStore(amalgmDir).credentials.map(sanitizeCredential);
+}
+
+export function upsertCredential(amalgmDir, input = {}) {
+  const rawKey = String(input.key || input.apiKey || '').trim();
+  if (!rawKey) throw new Error('Key is required');
+  const providerKind = input.providerKind || inferProviderKind({ baseUrl: input.baseUrl, key: rawKey });
+  const baseUrl = normalizeBaseUrl(input.baseUrl, providerKind);
+  const name = String(input.name || '').trim() || defaultName(providerKind, baseUrl);
+  const now = new Date().toISOString();
+  const store = readStore(amalgmDir);
+  const id = String(input.id || '').trim() || idFor();
+  const existing = store.credentials.find((item) => item.id === id);
+  const record = {
+    id,
+    name,
+    providerKind,
+    baseUrl,
+    keyHint: keyHint(rawKey),
+    tokenFingerprint: keyFingerprint(rawKey),
+    encryptedKey: encryptSecret(rawKey),
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  };
+  const next = store.credentials.filter((item) => item.id !== id);
+  next.push(record);
+  writeStore(amalgmDir, { version: STORE_VERSION, credentials: next });
+  return sanitizeCredential(record);
+}
+
+export function deleteCredential(amalgmDir, id) {
+  const store = readStore(amalgmDir);
+  const next = store.credentials.filter((item) => item.id !== id);
+  writeStore(amalgmDir, { version: STORE_VERSION, credentials: next });
+  return { ok: true, deleted: next.length !== store.credentials.length };
+}
+
+export function providerKindsForHarness(harness) {
+  if (harness === 'claude_code') return ['anthropic_compatible'];
+  if (harness === 'codex') return ['openai_compatible'];
+  if (harness === 'cursor') return ['cursor_api'];
+  if (harness === 'opencode') return ['ai_gateway', 'openai_compatible', 'anthropic_compatible'];
+  return [];
+}
+
+export function resolveCredential(amalgmDir, { credentialId, harness, providerKind } = {}) {
+  const store = readStore(amalgmDir);
+  const allowed = providerKind ? [providerKind] : providerKindsForHarness(harness);
+  const record = credentialId
+    ? store.credentials.find((item) => item.id === credentialId)
+    : store.credentials.find((item) => allowed.includes(item.providerKind));
+  if (!record) return null;
+  if (allowed.length && !allowed.includes(record.providerKind)) {
+    throw new Error(`Credential ${record.name || record.id} is not compatible with ${harness}`);
+  }
+  return {
+    ...sanitizeCredential(record),
+    baseUrl: record.baseUrl || normalizeBaseUrl('', record.providerKind),
+    key: decryptSecret(record.encryptedKey),
+  };
+}
+
+function defaultName(providerKind, baseUrl) {
+  if (providerKind === 'anthropic_compatible') return 'Anthropic';
+  if (providerKind === 'ai_gateway') return 'Vercel AI Gateway';
+  if (providerKind === 'cursor_api') return 'Cursor';
+  try {
+    const host = new URL(baseUrl).hostname.replace(/^api\./, '');
+    return host || 'OpenAI Compatible';
+  } catch {
+    return 'OpenAI Compatible';
+  }
+}