amalgm 0.0.0 → 0.0.1

package/runtime/scripts/amalgm-mcp/lib/prefs.js

@@ -0,0 +1,393 @@
+/**
+ * User model preferences — mirrors the Zustand harnessPreferences store.
+ *
+ * Hydrates on boot (non-blocking) from Supabase. Used to pick the right model
+ * for task/event/agent runs without requiring the caller to specify it.
+ */
+
+const { AMALGM_USER_ID } = require('../config');
+const { hasSupabase, supabaseSelect } = require('./supabase');
+
+const DEFAULT_SELECTED_MODELS = {
+  claude_code: 'anthropic/claude-opus-4.7',
+  codex: 'openai/gpt-5.4-thinking-xhigh',
+  opencode: 'opencode-moonshotai-kimi-k2.5',
+  pi: 'pi-anthropic-claude-sonnet-4.6',
+  amp: 'amp-default',
+  cursor: 'cursor/composer-2-fast',
+};
+
+const GATEWAY_PROVIDER_PREFIXES = [
+  'prime-intellect', 'arcee-ai',
+  'alibaba', 'amazon', 'anthropic', 'bytedance', 'cohere', 'deepseek',
+  'google', 'inception', 'kwaipilot', 'meituan', 'meta', 'minimax',
+  'mistral', 'moonshotai', 'morph', 'nvidia', 'openai',
+  'perplexity', 'xai', 'xiaomi', 'zai',
+];
+
+const CLAUDE_OPUS_4_7_1M_MODEL_ID = 'anthropic/claude-opus-4.7-1m';
+
+const CLAUDE_LEGACY_ALIASES = {
+  'claude-code-opus': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-47': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-46': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-45': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4.7': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4-7': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4.6': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4-6': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4.5': 'anthropic/claude-opus-4.7',
+  'claude-code-opus-4-5': 'anthropic/claude-opus-4.7',
+  'claude-code-opus1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'claude-code-opus-1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'claude-code-opus-4.7-1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'claude-code-opus-4-7-1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'claude-code-sonnet': 'anthropic/claude-sonnet-4.6',
+  'claude-code-sonnet-45': 'anthropic/claude-sonnet-4.6',
+  'claude-code-sonnet-4.6': 'anthropic/claude-sonnet-4.6',
+  'claude-code-sonnet-4-6': 'anthropic/claude-sonnet-4.6',
+  'claude-code-sonnet-4.5': 'anthropic/claude-sonnet-4.6',
+  'claude-code-sonnet-4-5': 'anthropic/claude-sonnet-4.6',
+  'claude-code-haiku': 'anthropic/claude-haiku-4.5',
+  'claude-code-haiku-4.5': 'anthropic/claude-haiku-4.5',
+  'claude-code-haiku-4-5': 'anthropic/claude-haiku-4.5',
+  'anthropic/claude-opus-4.6': 'anthropic/claude-opus-4.7',
+  'anthropic/claude-opus-4.5': 'anthropic/claude-opus-4.7',
+  'anthropic/claude-sonnet-4.5': 'anthropic/claude-sonnet-4.6',
+  'claude-opus-4.7-1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'claude-opus-4-7-1m': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  opus: 'anthropic/claude-opus-4.7',
+  opus1m: CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  'opus[1m]': CLAUDE_OPUS_4_7_1M_MODEL_ID,
+  sonnet: 'anthropic/claude-sonnet-4.6',
+  'sonnet[1m]': 'anthropic/claude-sonnet-4.6',
+  haiku: 'anthropic/claude-haiku-4.5',
+};
+
+const CLAUDE_HARNESS_MODELS = {
+  'anthropic/claude-opus-4.7': 'opus',
+  [CLAUDE_OPUS_4_7_1M_MODEL_ID]: 'opus[1m]',
+  'anthropic/claude-opus-4.6': 'opus',
+  'anthropic/claude-opus-4.5': 'opus',
+  'anthropic/claude-sonnet-4.6': 'sonnet',
+  'anthropic/claude-sonnet-4.5': 'sonnet',
+  'anthropic/claude-haiku-4.5': 'haiku',
+};
+
+const CODEX_THINKING_SUFFIX_RE = /:thinking-(low|medium|high|xhigh)$/i;
+const CODEX_LEGACY_THINKING_SUFFIX_RE = /-thinking-(low|medium|high|xhigh)$/i;
+
+const CURSOR_MODEL_ALIASES = {
+  'cursor-opus-4.6-thinking': 'anthropic/claude-opus-4.6-high-thinking',
+  'cursor-opus-4.6': 'anthropic/claude-opus-4.6-high',
+  'cursor-opus-4.5-thinking': 'anthropic/claude-opus-4.5-high-thinking',
+  'cursor-opus-4.5': 'anthropic/claude-opus-4.5-high',
+  'cursor-sonnet-4.5-thinking': 'anthropic/claude-sonnet-4.5-thinking',
+  'cursor-sonnet-4.5': 'anthropic/claude-sonnet-4.5',
+  'cursor-gemini-3-pro': 'google/gemini-3-pro',
+  'cursor-grok': 'xai/grok',
+  'cursor-gpt-5.4': 'openai/gpt-5.4-medium',
+  'cursor-anthropic/claude-opus-4.7': 'anthropic/claude-opus-4.7-xhigh',
+  'cursor-anthropic/claude-opus-4.6': 'anthropic/claude-opus-4.6-high',
+  'cursor-anthropic/claude-opus-4.5': 'anthropic/claude-opus-4.5-high',
+  'cursor-anthropic/claude-sonnet-4.6': 'anthropic/claude-sonnet-4.6-medium',
+  'cursor-anthropic/claude-sonnet-4.5': 'anthropic/claude-sonnet-4.5',
+  'cursor-anthropic/claude-sonnet-4': 'anthropic/claude-sonnet-4',
+  'cursor-openai/gpt-5.5': 'openai/gpt-5.5-medium',
+  'cursor-openai/gpt-5.4': 'openai/gpt-5.4-medium',
+  'cursor-openai/gpt-5.4-mini': 'openai/gpt-5.4-mini-medium',
+  'cursor-openai/gpt-5.4-nano': 'openai/gpt-5.4-nano-medium',
+  'cursor-openai/gpt-5.3-codex': 'openai/gpt-5.3-codex',
+  'cursor-openai/gpt-5.2': 'openai/gpt-5.2',
+  'cursor-google/gemini-3.1-pro-preview': 'google/gemini-3.1-pro',
+  'cursor-google/gemini-3.1-pro': 'google/gemini-3.1-pro',
+  'cursor-google/gemini-3-flash': 'google/gemini-3-flash',
+  'cursor-xai/grok-4.20': 'xai/grok-4.20',
+  'cursor-moonshotai/kimi-k2.5': 'moonshotai/kimi-k2.5',
+};
+
+const _selectedModels = { ...DEFAULT_SELECTED_MODELS };
+let _pinnedHarness = null;
+let _pinnedModel = null;
+let _prefsHydrated = false;
+
+function cleanModelId(value) {
+  return String(value || '').trim().replace(/^vercel\//i, '').toLowerCase();
+}
+
+function normalizeClaudeModelPart(modelPart) {
+  const hasOneMillionContext = /(?:\[\s*1m\s*\]|:1m|-1m)$/i.test(modelPart);
+  const base = modelPart
+    .replace(/\[\s*1m\s*\]$/i, '')
+    .replace(/:1m$/i, '')
+    .replace(/-1m$/i, '')
+    .replace(/-\d{8}$/, '')
+    .replace(/-(\d+)-(\d+)(?=$|[-:])/, '-$1.$2');
+  const currentBase = {
+    'claude-opus-4.6': 'claude-opus-4.7',
+    'claude-opus-4.5': 'claude-opus-4.7',
+    'claude-sonnet-4.5': 'claude-sonnet-4.6',
+  }[base] || base;
+  return hasOneMillionContext && currentBase === 'claude-opus-4.7'
+    ? currentBase + '-1m'
+    : currentBase;
+}
+
+function normalizeClaudeModelId(value) {
+  const cleaned = cleanModelId(value);
+  if (CLAUDE_LEGACY_ALIASES[cleaned]) return CLAUDE_LEGACY_ALIASES[cleaned];
+  if (cleaned.startsWith('anthropic/')) {
+    return 'anthropic/' + normalizeClaudeModelPart(cleaned.slice('anthropic/'.length));
+  }
+  if (cleaned.startsWith('claude-')) {
+    return 'anthropic/' + normalizeClaudeModelPart(cleaned);
+  }
+  return value;
+}
+
+function codexLegacyBaseToCanonical(value) {
+  const cleaned = cleanModelId(value);
+  if (cleaned.startsWith('openai/')) return cleaned;
+  if (cleaned.startsWith('codex-')) return 'openai/' + cleaned.slice('codex-'.length);
+  if (/^(gpt-|gpt\d|o-|o\d)/i.test(cleaned)) return 'openai/' + cleaned;
+  return value;
+}
+
+function codexThinkingVariantId(baseModelId, effort) {
+  return codexLegacyBaseToCanonical(baseModelId) + '-thinking-' + String(effort).toLowerCase();
+}
+
+function codexGatewayModelId(modelId) {
+  return modelId.replace(CODEX_THINKING_SUFFIX_RE, '').replace(CODEX_LEGACY_THINKING_SUFFIX_RE, '');
+}
+
+function codexHarnessModelId(modelId, effort) {
+  const baseModel = codexGatewayModelId(modelId).replace(/^openai\//, '');
+  if (effort && /^gpt-5\.[45](?:-mini)?$/i.test(baseModel)) {
+    return `${baseModel}/${effort}`;
+  }
+  return baseModel;
+}
+
+function cursorCliModelToCanonicalModelId(value) {
+  const cleaned = cleanModelId(value);
+  const cliModel = cleaned.startsWith('cursor-') ? cleaned.slice('cursor-'.length) : cleaned;
+  const prefixed = 'cursor-' + cliModel;
+  if (CURSOR_MODEL_ALIASES[prefixed]) return CURSOR_MODEL_ALIASES[prefixed];
+  if (cliModel.startsWith('cursor/')) return cliModel;
+  if (['auto', 'composer-2-fast', 'composer-2', 'composer-1.5', 'composer-1'].includes(cliModel)) {
+    return 'cursor/' + cliModel;
+  }
+  if (/^(gpt-|gpt\d|o-|o\d)/i.test(cliModel)) return 'openai/' + cliModel;
+  if (cliModel.startsWith('gemini-')) return 'google/' + cliModel;
+  if (cliModel === 'kimi-k2.5') return 'moonshotai/kimi-k2.5';
+  if (cliModel === 'grok') return 'xai/grok';
+  if (cliModel.startsWith('grok-4-20')) return 'xai/' + cliModel.replace(/^grok-4-20/, 'grok-4.20');
+  const opus47Match = cliModel.match(/^claude-opus-4-7(?:-(.+))?$/);
+  if (opus47Match) return 'anthropic/claude-opus-4.7' + (opus47Match[1] ? '-' + opus47Match[1] : '');
+  const claudeMatch = cliModel.match(/^claude-(4(?:\.\d+)?)-(opus|sonnet)(?:-(.+))?$/);
+  if (claudeMatch) {
+    const [, version, family, suffix] = claudeMatch;
+    return 'anthropic/claude-' + family + '-' + version + (suffix ? '-' + suffix : '');
+  }
+  if (cliModel.startsWith('claude-')) {
+    return 'anthropic/' + cliModel.replace(/-(\d+)-(\d+)(?=$|-)/, '-$1.$2');
+  }
+  return 'cursor/' + cliModel;
+}
+
+function normalizeCursorModelId(value) {
+  const cleaned = cleanModelId(value);
+  if (CURSOR_MODEL_ALIASES[cleaned]) return CURSOR_MODEL_ALIASES[cleaned];
+  if (cleaned.includes('/') && !cleaned.startsWith('cursor-')) return cleaned;
+  return cursorCliModelToCanonicalModelId(cleaned);
+}
+
+function cursorCanonicalModelIdToCliModel(value) {
+  const canonical = normalizeCursorModelId(value);
+  if (canonical.startsWith('cursor/')) return canonical.slice('cursor/'.length);
+  if (canonical.startsWith('cursor-')) return canonical.slice('cursor-'.length);
+  if (canonical.startsWith('openai/')) return canonical.slice('openai/'.length);
+  if (canonical.startsWith('google/')) return canonical.slice('google/'.length);
+  if (canonical.startsWith('moonshotai/')) return canonical.slice('moonshotai/'.length);
+  if (canonical.startsWith('xai/')) return canonical.slice('xai/'.length).replace(/^grok-4\.20/, 'grok-4-20');
+  if (canonical.startsWith('anthropic/')) {
+    const model = canonical.slice('anthropic/'.length);
+    const opus47Match = model.match(/^claude-opus-4\.7(?:-(.+))?$/);
+    if (opus47Match) return 'claude-opus-4-7' + (opus47Match[1] ? '-' + opus47Match[1] : '');
+    const claudeMatch = model.match(/^claude-(opus|sonnet)-(4(?:\.\d+)?)(?:-(.+))?$/);
+    if (claudeMatch) {
+      const [, family, version, suffix] = claudeMatch;
+      return 'claude-' + version + '-' + family + (suffix ? '-' + suffix : '');
+    }
+  }
+  return canonical;
+}
+
+function normalizeModelSelection(harnessId, modelId) {
+  if (!modelId) return { modelId: null, reasoningEffort: null };
+  const cleaned = cleanModelId(modelId);
+
+  if (harnessId === 'claude_code') {
+    return { modelId: normalizeClaudeModelId(cleaned), reasoningEffort: null };
+  }
+
+  if (harnessId === 'codex') {
+    const legacyThinkingMatch = cleaned.match(/^(codex-[a-z0-9.-]+(?:-[a-z0-9.-]+)*)-thinking-(low|medium|high|xhigh)$/i);
+    if (legacyThinkingMatch) {
+      const effort = legacyThinkingMatch[2].toLowerCase();
+      return {
+        modelId: codexThinkingVariantId(legacyThinkingMatch[1], effort),
+        reasoningEffort: effort,
+      };
+    }
+    const canonicalThinkingMatch = cleaned.match(/^((?:openai\/)?(?:gpt|o)[a-z0-9.-]+(?:-[a-z0-9.-]+)*)(?::thinking-|-thinking-)(low|medium|high|xhigh)$/i);
+    if (canonicalThinkingMatch) {
+      const effort = canonicalThinkingMatch[2].toLowerCase();
+      return {
+        modelId: codexThinkingVariantId(canonicalThinkingMatch[1], effort),
+        reasoningEffort: effort,
+      };
+    }
+    const slashThinkingMatch = cleaned.match(/^((?:openai\/)?(?:gpt|o)[a-z0-9.-]+(?:-[a-z0-9.-]+)*)\/(low|medium|high|xhigh)$/i);
+    if (slashThinkingMatch) {
+      const effort = slashThinkingMatch[2].toLowerCase();
+      return {
+        modelId: codexThinkingVariantId(slashThinkingMatch[1], effort),
+        reasoningEffort: effort,
+      };
+    }
+    return { modelId: codexLegacyBaseToCanonical(cleaned), reasoningEffort: null };
+  }
+
+  if (harnessId === 'cursor') {
+    return { modelId: normalizeCursorModelId(cleaned), reasoningEffort: null };
+  }
+
+  return { modelId, reasoningEffort: null };
+}
+
+function inferHarnessForModel(modelId, fallbackHarnessId) {
+  const cleaned = cleanModelId(modelId);
+  if (cleaned.startsWith('cursor-') || cleaned.startsWith('cursor/')) return 'cursor';
+  if (cleaned.startsWith('amp-')) return 'amp';
+  if (cleaned.startsWith('opencode-')) return 'opencode';
+  if (cleaned.startsWith('pi-')) return 'pi';
+  if (
+    cleaned.startsWith('claude-') ||
+    cleaned.startsWith('anthropic/claude-') ||
+    ['opus', 'opus1m', 'opus[1m]', 'sonnet', 'sonnet[1m]', 'haiku'].includes(cleaned)
+  ) {
+    return 'claude_code';
+  }
+  if (cleaned.startsWith('codex-') || cleaned.startsWith('openai/') || /^(gpt-|gpt\d|o-|o\d)/i.test(cleaned)) {
+    return 'codex';
+  }
+  return fallbackHarnessId;
+}
+
+function resolveCliModel(harnessId, modelId) {
+  const selection = normalizeModelSelection(harnessId, modelId);
+  const selectedModelId = selection.modelId || modelId;
+  if (harnessId === 'claude_code') {
+    return CLAUDE_HARNESS_MODELS[selectedModelId] ||
+      selectedModelId.replace(/^anthropic\//, '').replace(/-(\d+)\.(\d+)(?=$|-)/, '-$1-$2');
+  }
+  if (harnessId === 'codex') {
+    return codexHarnessModelId(selectedModelId, selection.reasoningEffort);
+  }
+  if (harnessId === 'cursor') {
+    return cursorCanonicalModelIdToCliModel(selectedModelId);
+  }
+  if (harnessId === 'amp') {
+    return selectedModelId;
+  }
+  // OpenCode / Pi: strip harness prefix and convert first dash to slash.
+  // e.g. "opencode-alibaba-qwen3-coder" → "vercel/alibaba/qwen3-coder"
+  for (const prefix of ['opencode-', 'pi-']) {
+    if (selectedModelId.startsWith(prefix)) {
+      const remainder = selectedModelId.slice(prefix.length);
+      const provider = GATEWAY_PROVIDER_PREFIXES.find((candidate) =>
+        remainder.startsWith(candidate + '-'));
+      if (provider) {
+        const gatewayId = provider + '/' + remainder.slice(provider.length + 1);
+        return prefix === 'opencode-' ? 'vercel/' + gatewayId : gatewayId;
+      }
+    }
+  }
+  return selectedModelId;
+}
+
+async function hydrateModelPreferences() {
+  if (_prefsHydrated || !hasSupabase()) return;
+  _prefsHydrated = true;
+  try {
+    const rows = await supabaseSelect(
+      'user_preferences',
+      `user_id=eq.${AMALGM_USER_ID}&select=preferences`,
+    );
+    if (!rows) return;
+    const preferences = rows?.[0]?.preferences;
+    const recentPrefs = preferences?.recent_prefs;
+    if (recentPrefs && typeof recentPrefs === 'object') {
+      for (const [h, m] of Object.entries(recentPrefs)) {
+        if (m) {
+          const normalized = normalizeModelSelection(h, m).modelId || m;
+          if (_selectedModels[h] !== normalized) _selectedModels[h] = normalized;
+        }
+      }
+    }
+    _pinnedHarness = preferences?.autopilot?.harness || null;
+    const rawPinnedModel = preferences?.autopilot?.model || null;
+    if (rawPinnedModel) {
+      const harnessForPinned =
+        _pinnedHarness ||
+        inferHarnessForModel(rawPinnedModel, preferences?.last_used?.harness || null);
+      _pinnedModel = harnessForPinned
+        ? normalizeModelSelection(harnessForPinned, rawPinnedModel).modelId || rawPinnedModel
+        : rawPinnedModel;
+    } else {
+      _pinnedModel = null;
+    }
+    console.log(
+      '[AmalgmMCP] Hydrated user prefs:',
+      JSON.stringify({
+        selectedModels: _selectedModels,
+        pinnedHarness: _pinnedHarness,
+        pinnedModel: _pinnedModel,
+      }),
+    );
+  } catch (err) {
+    console.warn('[AmalgmMCP] Failed to hydrate user prefs:', err.message);
+  }
+}
+
+function getSelectedModel(harnessId) {
+  if (_pinnedHarness === harnessId && _pinnedModel) return _pinnedModel;
+  return _selectedModels[harnessId] || DEFAULT_SELECTED_MODELS[harnessId] || null;
+}
+
+function resolveModelSelection(harnessId, uiModelId) {
+  const selectedModelId =
+    uiModelId ||
+    getSelectedModel(harnessId) ||
+    DEFAULT_SELECTED_MODELS[harnessId] ||
+    null;
+  if (!selectedModelId) {
+    return { modelId: null, cliModel: null, reasoningEffort: null };
+  }
+  const normalized = normalizeModelSelection(harnessId, selectedModelId);
+  const modelId = normalized.modelId || selectedModelId;
+  return {
+    modelId,
+    cliModel: resolveCliModel(harnessId, modelId),
+    reasoningEffort: normalized.reasoningEffort || null,
+  };
+}
+
+module.exports = {
+  DEFAULT_SELECTED_MODELS,
+  hydrateModelPreferences,
+  getSelectedModel,
+  resolveModelSelection,
+};

package/runtime/scripts/amalgm-mcp/lib/storage.js

@@ -0,0 +1,92 @@
+/**
+ * Storage primitives — atomic JSON and JSONL I/O on the local disk.
+ *
+ * Replaces the container-era /workspace + /persist dual-write. Locally we
+ * only ever write to ~/.amalgm/ (AMALGM_DIR). Single writer, no mirror.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Ensure a directory exists (mkdir -p).
+ */
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+/**
+ * Read a JSON file, returning `fallback` on ENOENT or parse error.
+ */
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Write JSON atomically: tmp file + rename. Falls back to non-atomic on
+ * rename failure (e.g. cross-device; shouldn't happen locally).
+ */
+function writeJsonAtomic(file, data) {
+  const json = JSON.stringify(data, null, 2);
+  const tmp = file + '.tmp';
+  fs.writeFileSync(tmp, json);
+  fs.renameSync(tmp, file);
+}
+
+/**
+ * Delete any leftover `.{name}.tmp` files from crashed writes.
+ */
+function cleanupStaleTmp(dir, prefix = '.') {
+  try {
+    for (const entry of fs.readdirSync(dir)) {
+      if (entry.startsWith(prefix) && entry.endsWith('.tmp')) {
+        fs.rmSync(path.join(dir, entry), { force: true });
+      }
+    }
+  } catch {
+    // Best-effort cleanup.
+  }
+}
+
+/**
+ * Append a JSON entry as a JSONL line.
+ */
+function appendJsonl(file, entry) {
+  ensureDir(path.dirname(file));
+  fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+}
+
+/**
+ * Read the last N entries from a JSONL file. Returns [] if missing.
+ */
+function tailJsonl(file, limit = 20) {
+  if (!fs.existsSync(file)) return [];
+  try {
+    const lines = fs.readFileSync(file, 'utf-8').trim().split('\n').filter(Boolean);
+    return lines
+      .slice(-limit)
+      .map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+module.exports = {
+  ensureDir,
+  readJson,
+  writeJsonAtomic,
+  cleanupStaleTmp,
+  appendJsonl,
+  tailJsonl,
+};

package/runtime/scripts/amalgm-mcp/lib/supabase.js

@@ -0,0 +1,118 @@
+/**
+ * Supabase REST client — optional.
+ *
+ * Local-first: this module is usable but *not required*. If Supabase isn't
+ * configured, hasSupabase() returns false and every helper no-ops (returns
+ * null). Task runs and agent conversations still work; they just don't create
+ * a `sessions` row in the cloud DB.
+ *
+ * When the user is signed in and the orchestrator provides an HMAC proxy
+ * token, writes go through the Fly.io proxy → Supabase.
+ */
+
+const {
+  SUPABASE_URL,
+  SUPABASE_AUTH_HEADERS,
+  PROXY_BASE_URL,
+  PROXY_TOKEN,
+  AMALGM_USER_ID,
+} = require('../config');
+const {
+  DEFAULT_PROXY_BASE_URL,
+  ensureFreshProxyToken,
+  readProxyToken,
+} = require('../../proxy-token-store');
+
+function hasSupabase() {
+  return !!(
+    AMALGM_USER_ID
+    && (
+      (SUPABASE_URL && SUPABASE_AUTH_HEADERS.apikey)
+      || readProxyToken()
+      || PROXY_TOKEN
+    )
+  );
+}
+
+async function supabaseContext() {
+  if (!AMALGM_USER_ID) return null;
+  if (SUPABASE_URL && SUPABASE_AUTH_HEADERS.apikey) {
+    return { url: SUPABASE_URL, headers: SUPABASE_AUTH_HEADERS };
+  }
+  const token = await ensureFreshProxyToken({ logger: console }) || readProxyToken() || PROXY_TOKEN;
+  const proxyBase = (PROXY_BASE_URL || DEFAULT_PROXY_BASE_URL).replace(/\/$/, '');
+  if (!token || !proxyBase) return null;
+  return {
+    url: `${proxyBase}/supabase`,
+    headers: { Authorization: `Bearer ${token}` },
+  };
+}
+
+async function supabaseInsert(table, data) {
+  const ctx = await supabaseContext();
+  if (!ctx) return null;
+  const res = await fetch(`${ctx.url}/rest/v1/${table}`, {
+    method: 'POST',
+    headers: {
+      ...ctx.headers,
+      'Content-Type': 'application/json',
+      Prefer: 'return=representation',
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(
+      `[AmalgmMCP:Supabase] INSERT ${table} failed: ${res.status} ${text.slice(0, 200)}`,
+    );
+    return null;
+  }
+  const rows = await res.json();
+  return Array.isArray(rows) ? rows[0] : rows;
+}
+
+async function supabasePatch(table, matchCol, matchVal, data) {
+  const ctx = await supabaseContext();
+  if (!ctx) return null;
+  const res = await fetch(`${ctx.url}/rest/v1/${table}?${matchCol}=eq.${matchVal}`, {
+    method: 'PATCH',
+    headers: {
+      ...ctx.headers,
+      'Content-Type': 'application/json',
+      Prefer: 'return=representation',
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(
+      `[AmalgmMCP:Supabase] PATCH ${table} failed: ${res.status} ${text.slice(0, 200)}`,
+    );
+    return null;
+  }
+  return res.json();
+}
+
+async function supabaseSelect(table, query) {
+  const ctx = await supabaseContext();
+  if (!ctx) return null;
+  const res = await fetch(`${ctx.url}/rest/v1/${table}?${query}`, {
+    headers: ctx.headers,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(
+      `[AmalgmMCP:Supabase] SELECT ${table} failed: ${res.status} ${text.slice(0, 200)}`,
+    );
+    return null;
+  }
+  return res.json();
+}
+
+module.exports = {
+  hasSupabase,
+  supabaseContext,
+  supabaseInsert,
+  supabasePatch,
+  supabaseSelect,
+};