acdev 1.0.1 → 1.0.3

package/src/models.js

@@ -0,0 +1,366 @@
+/**
+ * Resolve Claude model options for the Settings UI.
+ *
+ * Prefer Anthropic Models API (`GET /v1/models`) when an API key, auth token,
+ * or Claude Code OAuth credential is available. Claude Agent SDK and Claude CLI
+ * do not expose a list endpoint. Subscription-only login without a readable
+ * credential falls back to a curated Claude Code / Agent SDK list.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * Curated Claude Agent SDK / Claude Code model ids used as defaults + fallback.
+ * Prefer documented Code aliases and Anthropic API ids (not invented snapshots).
+ */
+export const MODEL_OPTIONS = [
+  { id: 'claude-sonnet-5', label: 'Sonnet 5' },
+  { id: 'claude-opus-5', label: 'Opus 5' },
+  { id: 'claude-fable-5', label: 'Fable 5' },
+  { id: 'claude-haiku-4-5', label: 'Haiku 4.5' },
+  { id: 'sonnet', label: 'sonnet (latest)' },
+  { id: 'opus', label: 'opus (latest)' },
+  { id: 'haiku', label: 'haiku (latest)' },
+  { id: 'fable', label: 'fable (latest)' },
+  { id: 'best', label: 'best' },
+  { id: 'opusplan', label: 'opusplan' },
+  { id: 'claude-sonnet-4-6', label: 'Sonnet 4.6' },
+  { id: 'claude-opus-4-8', label: 'Opus 4.8' },
+  { id: 'claude-opus-4-7', label: 'Opus 4.7' },
+  { id: 'claude-opus-4-6', label: 'Opus 4.6' },
+  { id: 'claude-sonnet-4-5', label: 'Sonnet 4.5' },
+  { id: 'claude-opus-4-5', label: 'Opus 4.5' },
+  { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5 (20251001)' },
+  { id: 'claude-sonnet-4-5-20250929', label: 'Sonnet 4.5 (20250929)' },
+  { id: 'claude-opus-4-5-20251101', label: 'Opus 4.5 (20251101)' },
+];
+
+export const DEFAULT_MODEL = 'claude-sonnet-5';
+
+/** Loose model id shape accepted by config (API ids + Claude Code aliases). */
+export const MODEL_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+
+const ANTHROPIC_MODELS_URL = 'https://api.anthropic.com/v1/models';
+const ANTHROPIC_VERSION = '2023-06-01';
+const CACHE_TTL_MS = 5 * 60_000;
+const KEYCHAIN_SERVICE = 'Claude Code-credentials';
+
+/** @typedef {{ id: string, name?: string, label?: string }} ModelOption */
+/** @typedef {'anthropic' | 'fallback'} ModelsSource */
+/** @typedef {{ models: ModelOption[], selected: string, source: ModelsSource }} ModelsListResult */
+
+/** @type {{ expiresAt: number, result: Omit<ModelsListResult, 'selected'> } | null} */
+let cache = null;
+
+/** @type {typeof fetch | null} */
+let fetchImpl = null;
+
+/** @type {() => NodeJS.ProcessEnv} */
+let envResolver = () => process.env;
+
+/** @type {() => string | null} */
+let credentialsTokenResolver = defaultCredentialsTokenResolver;
+
+/** @param {typeof fetch} fn */
+export function _setFetchImpl(fn) {
+  fetchImpl = fn;
+}
+
+export function _resetFetchImpl() {
+  fetchImpl = null;
+}
+
+/** @param {() => NodeJS.ProcessEnv} fn */
+export function _setEnvResolver(fn) {
+  envResolver = fn;
+}
+
+export function _resetEnvResolver() {
+  envResolver = () => process.env;
+}
+
+/** @param {() => string | null} fn */
+export function _setCredentialsTokenResolver(fn) {
+  credentialsTokenResolver = fn;
+}
+
+export function _resetCredentialsTokenResolver() {
+  credentialsTokenResolver = defaultCredentialsTokenResolver;
+}
+
+export function _resetModelsCache() {
+  cache = null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isValidModelId(value) {
+  return typeof value === 'string' && MODEL_ID_RE.test(value.trim());
+}
+
+/**
+ * @param {string} id
+ * @param {string} [displayName]
+ * @returns {ModelOption}
+ */
+function toOption(id, displayName) {
+  const name = (displayName || '').trim();
+  return name ? { id, name, label: name } : { id, label: id };
+}
+
+/**
+ * Merge curated options (stable order / aliases) with live Anthropic rows.
+ * Same ids keep curated position but prefer live display names.
+ * @param {ModelOption[]} curated
+ * @param {ModelOption[]} live
+ * @returns {ModelOption[]}
+ */
+function mergeModelLists(curated, live) {
+  const liveById = new Map();
+  for (const m of live) {
+    if (m?.id) liveById.set(m.id, m);
+  }
+  const seen = new Set();
+  /** @type {ModelOption[]} */
+  const out = [];
+  for (const m of curated) {
+    if (!m?.id || seen.has(m.id)) continue;
+    seen.add(m.id);
+    const liveHit = liveById.get(m.id);
+    if (liveHit) {
+      const label = liveHit.label || liveHit.name || m.label || m.id;
+      const name = liveHit.name || liveHit.label || m.name;
+      out.push(name ? { id: m.id, name, label } : { id: m.id, label });
+    } else {
+      out.push({ ...m });
+    }
+  }
+  for (const m of live) {
+    if (!m?.id || seen.has(m.id)) continue;
+    seen.add(m.id);
+    out.push({ ...m });
+  }
+  return out;
+}
+
+/**
+ * @param {ModelOption[]} models
+ * @param {string} selected
+ * @returns {ModelOption[]}
+ */
+function ensureSelected(models, selected) {
+  if (!selected || models.some((m) => m.id === selected)) return models;
+  return [toOption(selected), ...models];
+}
+
+/**
+ * Extract Claude Code OAuth access token from a credentials JSON blob.
+ * @param {string} raw
+ * @returns {string | null}
+ */
+export function parseClaudeCodeOauthAccessToken(raw) {
+  try {
+    const parsed = JSON.parse(String(raw || '').trim());
+    const tok = parsed?.claudeAiOauth?.accessToken;
+    if (typeof tok === 'string' && tok.trim()) return tok.trim();
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Read plaintext Claude Code credentials file (`~/.claude/.credentials.json`
+ * or `$CLAUDE_CONFIG_DIR/.credentials.json`).
+ * @returns {string | null}
+ */
+function readClaudeCodeCredentialsFile() {
+  const env = envResolver();
+  /** @type {string[]} */
+  const dirs = [];
+  const configDir = (env.CLAUDE_CONFIG_DIR || '').trim();
+  if (configDir) dirs.push(configDir);
+  dirs.push(join(homedir(), '.claude'));
+
+  for (const dir of dirs) {
+    const path = join(dir, '.credentials.json');
+    try {
+      if (!existsSync(path)) continue;
+      const tok = parseClaudeCodeOauthAccessToken(readFileSync(path, 'utf8'));
+      if (tok) return tok;
+    } catch {
+      // ignore unreadable paths
+    }
+  }
+  return null;
+}
+
+/**
+ * Read Claude Code OAuth token from macOS Keychain (browser `claude auth login`).
+ * @returns {string | null}
+ */
+function readClaudeCodeKeychainToken() {
+  if (process.platform !== 'darwin') return null;
+  try {
+    const raw = execFileSync(
+      'security',
+      ['find-generic-password', '-s', KEYCHAIN_SERVICE, '-w'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+    );
+    return parseClaudeCodeOauthAccessToken(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Claude Code subscription OAuth token from local credential stores.
+ * @returns {string | null}
+ */
+function defaultCredentialsTokenResolver() {
+  return readClaudeCodeCredentialsFile() || readClaudeCodeKeychainToken();
+}
+
+/**
+ * Build auth headers for Anthropic Models API from env or Claude Code login.
+ * @returns {{ headers: Record<string, string>, auth: string } | null}
+ */
+function resolveAnthropicAuth() {
+  const env = envResolver();
+  const apiKey = (env.ANTHROPIC_API_KEY || '').trim();
+  if (apiKey) {
+    return {
+      auth: 'api-key',
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+  const bearer = (
+    env.ANTHROPIC_AUTH_TOKEN ||
+    env.CLAUDE_CODE_OAUTH_TOKEN ||
+    ''
+  ).trim();
+  if (bearer) {
+    return {
+      auth: 'bearer',
+      headers: {
+        Authorization: `Bearer ${bearer}`,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+
+  const stored = (credentialsTokenResolver() || '').trim();
+  if (stored) {
+    return {
+      auth: 'claude-code-login',
+      headers: {
+        Authorization: `Bearer ${stored}`,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+  return null;
+}
+
+/**
+ * @param {Response} res
+ * @returns {Promise<ModelOption[]>}
+ */
+async function parseModelsResponse(res) {
+  if (!res.ok) {
+    throw new Error(`Anthropic Models API HTTP ${res.status}`);
+  }
+  const body = await res.json();
+  const rows = Array.isArray(body?.data) ? body.data : [];
+  /** @type {ModelOption[]} */
+  const models = [];
+  for (const row of rows) {
+    const id = typeof row?.id === 'string' ? row.id.trim() : '';
+    if (!isValidModelId(id)) continue;
+    const display =
+      typeof row.display_name === 'string'
+        ? row.display_name
+        : typeof row.name === 'string'
+          ? row.name
+          : '';
+    models.push(toOption(id, display));
+  }
+  if (models.length === 0) {
+    throw new Error('Anthropic Models API returned no models');
+  }
+  return models;
+}
+
+/**
+ * Fetch live models from Anthropic (no cache).
+ * @returns {Promise<ModelOption[]>}
+ */
+export async function fetchAnthropicModels() {
+  const auth = resolveAnthropicAuth();
+  if (!auth) {
+    throw new Error('No Anthropic API credentials for models list');
+  }
+  const doFetch = fetchImpl || globalThis.fetch;
+  if (typeof doFetch !== 'function') {
+    throw new Error('fetch is not available');
+  }
+  const res = await doFetch(ANTHROPIC_MODELS_URL, {
+    method: 'GET',
+    headers: auth.headers,
+  });
+  return parseModelsResponse(res);
+}
+
+/**
+ * List models for the UI.
+ * @param {{ selected?: string, force?: boolean }} [opts]
+ * @returns {Promise<ModelsListResult>}
+ */
+export async function listModels(opts = {}) {
+  const selectedRaw = opts.selected;
+  const selected = isValidModelId(selectedRaw)
+    ? String(selectedRaw).trim()
+    : DEFAULT_MODEL;
+  const force = opts.force === true;
+  const now = Date.now();
+
+  if (!force && cache && cache.expiresAt > now) {
+    return {
+      ...cache.result,
+      models: ensureSelected(cache.result.models, selected),
+      selected,
+    };
+  }
+
+  try {
+    const live = await fetchAnthropicModels();
+    // Keep curated Claude Code aliases available alongside API ids.
+    const models = ensureSelected(
+      mergeModelLists(
+        MODEL_OPTIONS.map((m) => ({ ...m })),
+        live
+      ),
+      selected
+    );
+    const result = { models, source: /** @type {ModelsSource} */ ('anthropic') };
+    cache = { expiresAt: now + CACHE_TTL_MS, result };
+    return { ...result, selected };
+  } catch {
+    const models = ensureSelected(
+      MODEL_OPTIONS.map((m) => ({ ...m })),
+      selected
+    );
+    const result = { models, source: /** @type {ModelsSource} */ ('fallback') };
+    // Short cache on fallback so we retry Anthropic soon after auth is saved.
+    cache = { expiresAt: now + 30_000, result };
+    return { ...result, selected };
+  }
+}

package/src/server.js

@@ -33,6 +33,7 @@ import {
 } from './agent.js';
 import { publicConfig, updateConfig } from './config.js';
 import { upsertEnvVars } from './env.js';
+import { listModels } from './models.js';
 import { splitIssueUrls } from './urls.js';
 import { usageFromLogs, withJobUsage } from './usage.js';
 
@@ -76,6 +77,23 @@ function jobDedupeKey(job) {
   }
   return `github:${job.issueUrl}`;
 }
+
+/**
+ * Empty string = leave the existing secret unchanged; null = clear.
+ * @param {Record<string, string | null>} envPatch
+ * @param {string} envKey
+ * @param {unknown} value
+ */
+function applySecretField(envPatch, envKey, value) {
+  if (value === undefined) return;
+  if (value === null) {
+    envPatch[envKey] = null;
+    return;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    envPatch[envKey] = value.trim();
+  }
+}
 /**
  * Normalize + validate POST /api/jobs/:id/review body.
  * @param {unknown} body
@@ -146,6 +164,8 @@ export function normalizeReviewComments(body) {
  *     listChangedFiles?: typeof listChangedFiles,
  *     applyFileExclusions?: typeof applyFileExclusions,
  *     transitionJiraIssue?: Function,
+ *     addJiraIssueLabel?: Function,
+ *     closeJiraIssue?: Function,
  *     addIssueLabel?: Function,
  *     closeIssue?: Function,
  *     resolveJiraCredentials?: Function,
@@ -447,11 +467,25 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
     }
   });
 
+  app.get('/api/models', async (req, res) => {
+    try {
+      const force =
+        req.query.refresh === '1' ||
+        req.query.refresh === 'true' ||
+        req.query.force === '1';
+      const result = await listModels({ selected: config.model, force });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   app.patch('/api/config', (req, res) => {
     try {
       const patch = req.body || {};
 
-      // Jira secrets → .env (never persisted in config.json)
+      // Secrets → .acdev/.env (never persisted in config.json).
+      // Empty string = leave unchanged; null = clear.
       /** @type {Record<string, string | null>} */
       const envPatch = {};
       if (patch.jiraEmail !== undefined) {
@@ -459,16 +493,10 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
           typeof patch.jiraEmail === 'string' ? patch.jiraEmail.trim() : '';
         envPatch.JIRA_EMAIL = email || null;
       }
-      if (patch.jiraApiToken !== undefined) {
-        const token =
-          typeof patch.jiraApiToken === 'string' ? patch.jiraApiToken.trim() : '';
-        // Empty string means "leave unchanged" when token already set — only clear if null
-        if (patch.jiraApiToken === null) {
-          envPatch.JIRA_API_TOKEN = null;
-        } else if (token) {
-          envPatch.JIRA_API_TOKEN = token;
-        }
-      }
+      applySecretField(envPatch, 'JIRA_API_TOKEN', patch.jiraApiToken);
+      applySecretField(envPatch, 'GH_TOKEN', patch.ghToken);
+      applySecretField(envPatch, 'ANTHROPIC_API_KEY', patch.anthropicApiKey);
+      applySecretField(envPatch, 'CLAUDE_CODE_OAUTH_TOKEN', patch.claudeOauthToken);
       if (patch.jiraBaseUrl !== undefined && typeof patch.jiraBaseUrl === 'string') {
         // Also mirror base URL into env for convenience when set via Settings
         const trimmed = patch.jiraBaseUrl.trim();
@@ -483,6 +511,9 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
       const {
         jiraEmail: _e,
         jiraApiToken: _t,
+        ghToken: _gh,
+        anthropicApiKey: _ak,
+        claudeOauthToken: _oa,
         ...configPatch
       } = patch;
       updateConfig(repoRoot, config, configPatch);
@@ -814,6 +845,8 @@ export function createServer({ repoRoot, config, store, useStubAgent = false, de
             appendLog: (j, type, payload) => appendLog(j, type, payload),
             deps: {
               transitionJiraIssue: deps.transitionJiraIssue,
+              addJiraIssueLabel: deps.addJiraIssueLabel,
+              closeJiraIssue: deps.closeJiraIssue,
               addIssueLabel: deps.addIssueLabel,
               closeIssue: deps.closeIssue,
               resolveJiraCredentials: deps.resolveJiraCredentials,