acdev 1.0.4 → 1.0.6

package/src/agent.js

@@ -2,6 +2,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { ensureNoAiAttributionSettings, getIssueTitle } from './git.js';
+import { isValidLlmProvider } from './models.js';
 import { extractUsageFromResult } from './usage.js';
 
 const execFileAsync = promisify(execFile);
@@ -396,6 +397,61 @@ async function fetchIssueTitle(issueUrl, worktreePath) {
  */
 export const DISALLOWED_AGENT_TOOLS = ['Task', 'TaskOutput', 'AskUserQuestion'];
 
+const OPENROUTER_ANTHROPIC_BASE_URL = 'https://openrouter.ai/api';
+
+/**
+ * Run an agent query with provider-specific Anthropic env overrides.
+ * OpenRouter uses Claude Agent SDK via Anthropic-compatible "skin" routing.
+ * @template T
+ * @param {object} config
+ * @param {() => Promise<T>} fn
+ * @returns {Promise<T>}
+ */
+export async function withLlmProviderEnv(config, fn) {
+  const provider = isValidLlmProvider(config.llmProvider) ? config.llmProvider : 'claude';
+  if (provider !== 'openrouter') {
+    return fn();
+  }
+
+  const apiKey = (process.env.OPENROUTER_API_KEY || '').trim();
+  if (!apiKey) {
+    throw new Error(
+      'OpenRouter is not authenticated. Add OPENROUTER_API_KEY in Settings → Authentication.'
+    );
+  }
+
+  /** @type {Record<string, string | undefined>} */
+  const saved = {
+    ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL,
+    ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+    HTTP_REFERER: process.env.HTTP_REFERER,
+    X_TITLE: process.env.X_TITLE,
+  };
+
+  process.env.ANTHROPIC_BASE_URL = OPENROUTER_ANTHROPIC_BASE_URL;
+  process.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+  process.env.ANTHROPIC_API_KEY = '';
+  if (!process.env.HTTP_REFERER) {
+    process.env.HTTP_REFERER = 'https://github.com/acdev';
+  }
+  if (!process.env.X_TITLE) {
+    process.env.X_TITLE = 'acdev';
+  }
+
+  try {
+    return await fn();
+  } finally {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
 /**
  * Prefer the first successful SDK result. A known SDK bug can emit a follow-up
  * `error_during_execution` right after success when async subagents finish.
@@ -422,76 +478,78 @@ export function mergeAgentResult(current, incoming) {
  * }} params
  */
 async function runAgentQuery({ prompt, worktreePath, config, onEvent, queryFn = query }) {
-  const timeoutMs = config.agentTimeoutMs ?? 900_000;
-  let lastMessage = null;
-  let resultMessage = null;
-  const abortController = new AbortController();
-
-  // Claude Agent SDK defaults to injecting Co-Authored-By trailers into commit
-  // instructions unless attribution is cleared via Claude settings.
-  ensureNoAiAttributionSettings(worktreePath);
-
-  const runLoop = async () => {
-    try {
-      for await (const message of queryFn({
-        // String prompt = single-turn SDK input (still uses stream-json transport).
-        prompt,
-        options: {
-          cwd: worktreePath,
-          allowedTools: config.allowedTools,
-          disallowedTools: DISALLOWED_AGENT_TOOLS,
-          permissionMode: 'acceptEdits',
-          maxTurns: config.maxAgentTurns,
-          model: config.model || 'claude-sonnet-5',
-          // Load only local settings so our empty attribution wins without
-          // pulling in unrelated user settings.
-          settingSources: ['local'],
-          abortController,
-        },
-      })) {
-        onEvent(message);
-        lastMessage = message;
-        if (message?.type === 'result') {
-          resultMessage = mergeAgentResult(resultMessage, message);
-          // First success is authoritative — stop before SDK async-task teardown
-          // can overwrite it with a spurious streaming-mode error.
-          if (message.subtype === 'success') {
-            abortController.abort();
-            break;
+  return withLlmProviderEnv(config, async () => {
+    const timeoutMs = config.agentTimeoutMs ?? 900_000;
+    let lastMessage = null;
+    let resultMessage = null;
+    const abortController = new AbortController();
+
+    // Claude Agent SDK defaults to injecting Co-Authored-By trailers into commit
+    // instructions unless attribution is cleared via Claude settings.
+    ensureNoAiAttributionSettings(worktreePath);
+
+    const runLoop = async () => {
+      try {
+        for await (const message of queryFn({
+          // String prompt = single-turn SDK input (still uses stream-json transport).
+          prompt,
+          options: {
+            cwd: worktreePath,
+            allowedTools: config.allowedTools,
+            disallowedTools: DISALLOWED_AGENT_TOOLS,
+            permissionMode: 'acceptEdits',
+            maxTurns: config.maxAgentTurns,
+            model: config.model || 'claude-sonnet-5',
+            // Load only local settings so our empty attribution wins without
+            // pulling in unrelated user settings.
+            settingSources: ['local'],
+            abortController,
+          },
+        })) {
+          onEvent(message);
+          lastMessage = message;
+          if (message?.type === 'result') {
+            resultMessage = mergeAgentResult(resultMessage, message);
+            // First success is authoritative — stop before SDK async-task teardown
+            // can overwrite it with a spurious streaming-mode error.
+            if (message.subtype === 'success') {
+              abortController.abort();
+              break;
+            }
           }
         }
+      } catch (err) {
+        // Aborting after success can surface as an iterator/abort error.
+        if (resultMessage?.subtype === 'success') return;
+        throw err;
       }
-    } catch (err) {
-      // Aborting after success can surface as an iterator/abort error.
-      if (resultMessage?.subtype === 'success') return;
-      throw err;
-    }
-  };
+    };
 
-  let timeoutId;
-  try {
-    await Promise.race([
-      runLoop(),
-      new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
-          abortController.abort();
-          reject(new Error(`Agent timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-      }),
-    ]);
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
-  }
+    let timeoutId;
+    try {
+      await Promise.race([
+        runLoop(),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            abortController.abort();
+            reject(new Error(`Agent timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
 
-  if (!resultMessage || resultMessage.subtype !== 'success') {
-    const detail = lastMessage ? JSON.stringify(lastMessage) : 'no result received';
-    throw new Error(`Agent did not complete successfully: ${detail}`);
-  }
+    if (!resultMessage || resultMessage.subtype !== 'success') {
+      const detail = lastMessage ? JSON.stringify(lastMessage) : 'no result received';
+      throw new Error(`Agent did not complete successfully: ${detail}`);
+    }
 
-  const resultText = resultMessage.result ?? '';
-  const meta = extractPrMetadata(resultText);
-  const usage = extractUsageFromResult(resultMessage);
-  return { resultText, meta, usage };
+    const resultText = resultMessage.result ?? '';
+    const meta = extractPrMetadata(resultText);
+    const usage = extractUsageFromResult(resultMessage);
+    return { resultText, meta, usage };
+  });
 }
 
 function stubAgentResult(onEvent, title, body) {

package/src/claude-auth.js

@@ -90,22 +90,16 @@ export function publicClaudeAuthMethod(result) {
 }
 
 /**
- * Human-readable startup error for a failed {@link checkClaudeAuth}.
+ * Human-readable startup warning for a failed {@link checkClaudeAuth}.
+ * Soft-auth: this is not fatal — the server still starts so Settings can configure auth.
  * @param {ClaudeAuthResult} [_result]
  */
 export function formatClaudeAuthError(_result) {
   return [
-    '✖ No Anthropic / Claude Code authentication found.',
-    '',
-    'Authenticate with one of:',
-    '  1. Claude Pro/Max subscription (browser): install Claude Code, then run',
-    '     `claude auth login`. Settings cannot complete browser OAuth — that still',
-    '     needs the CLI on this machine.',
-    '  2. Subscription token: `claude setup-token`, then set CLAUDE_CODE_OAUTH_TOKEN',
-    '     in Settings → Claude authentication or `.acdev/.env`',
-    '  3. Anthropic API key (API billing): set ANTHROPIC_API_KEY in Settings or `.acdev/.env`',
-    '',
-    'API keys take precedence over subscription login. For UI-only testing without',
-    'auth: pass `--stub-agent`.',
+    '⚠ Claude is not authenticated — server will still start.',
+    '  Open Settings → Authentication to add an API key or OAuth token',
+    '  (or set ANTHROPIC_API_KEY / CLAUDE_CODE_OAUTH_TOKEN in `.acdev/.env`).',
+    '  Browser login still needs `claude auth login` on this machine.',
+    '  For UI-only testing without auth: pass `--stub-agent`.',
   ].join('\n');
 }

package/src/config.js

@@ -6,12 +6,20 @@ import { checkGhAuth, githubTokenFromEnv, originRemoteInfo } from './gh-auth.js'
 import { normalizeJiraBaseUrl } from './jira.js';
 import {
   DEFAULT_MODEL,
-  MODEL_OPTIONS,
+  DEFAULT_OPENROUTER_MODEL,
+  LLM_PROVIDERS,
+  NO_MODEL,
   isValidModelId,
+  isNoModel,
+  isValidLlmProvider,
+  defaultModelForProvider,
+  isModelIdForProvider,
+  curatedModelOptions,
 } from './models.js';
+import { checkOpenRouterAuth } from './openrouter-auth.js';
 import { dataDir } from './paths.js';
 
-export { DEFAULT_MODEL, MODEL_OPTIONS } from './models.js';
+export { DEFAULT_MODEL, DEFAULT_OPENROUTER_MODEL, CLAUDE_MODEL_OPTIONS, MODEL_OPTIONS, OPENROUTER_MODEL_OPTIONS, LLM_PROVIDERS, NO_MODEL } from './models.js';
 
 /** Tool names the agent may be granted via config. */
 export const KNOWN_TOOLS = ['Read', 'Glob', 'Grep', 'Edit', 'Write', 'Bash'];
@@ -61,7 +69,10 @@ const DEFAULTS = {
   maxAgentTurns: 30,
   allowedTools: [...KNOWN_TOOLS],
   agentTimeoutMs: 900_000,
+  llmProvider: /** @type {'claude' | 'openrouter'} */ ('claude'),
   model: DEFAULT_MODEL,
+  /** Last valid model selection per LLM provider (for restore on provider switch). */
+  lastModelsByProvider: /** @type {Record<string, string>} */ ({}),
   ticketSource: /** @type {'github' | 'jira'} */ ('github'),
   jiraBaseUrl: '',
   /** PR body phrase for Jira tickets, e.g. "Relates to PROJ-123". */
@@ -70,6 +81,79 @@ const DEFAULTS = {
   githubRules: structuredClone(DEFAULT_GITHUB_RULES),
 };
 
+/**
+ * @param {unknown} raw
+ * @returns {Record<string, string>}
+ */
+function normalizeLastModelsByProvider(raw) {
+  /** @type {Record<string, string>} */
+  const out = {};
+  if (raw == null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return out;
+  }
+  for (const provider of LLM_PROVIDERS) {
+    const value = /** @type {Record<string, unknown>} */ (raw)[provider];
+    if (typeof value !== 'string' || isNoModel(value) || !isValidModelId(value)) {
+      continue;
+    }
+    const id = value.trim();
+    if (isModelIdForProvider(id, provider)) {
+      out[provider] = id;
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {object} config
+ * @param {'claude' | 'openrouter'} provider
+ * @param {string} model
+ */
+function rememberModelForProvider(config, provider, model) {
+  if (!isValidLlmProvider(provider)) return;
+  if (isNoModel(model) || !isValidModelId(model)) return;
+  const id = String(model).trim();
+  if (!isModelIdForProvider(id, provider)) return;
+  if (
+    !config.lastModelsByProvider ||
+    typeof config.lastModelsByProvider !== 'object' ||
+    config.lastModelsByProvider === DEFAULTS.lastModelsByProvider
+  ) {
+    config.lastModelsByProvider = {
+      ...(config.lastModelsByProvider &&
+      typeof config.lastModelsByProvider === 'object' &&
+      config.lastModelsByProvider !== DEFAULTS.lastModelsByProvider
+        ? config.lastModelsByProvider
+        : {}),
+    };
+  }
+  config.lastModelsByProvider[provider] = id;
+}
+
+/**
+ * Pick model for a provider: preferred if in catalog, else last stored, else no selection.
+ * @param {object} config
+ * @param {'claude' | 'openrouter'} provider
+ * @param {string} [preferredModel]
+ * @returns {string}
+ */
+function resolveModelForProvider(config, provider, preferredModel) {
+  const candidate =
+    preferredModel != null ? preferredModel : config.model;
+  if (!isNoModel(candidate) && isModelIdForProvider(candidate, provider)) {
+    return String(candidate).trim();
+  }
+  const stored = config.lastModelsByProvider?.[provider];
+  if (
+    typeof stored === 'string' &&
+    !isNoModel(stored) &&
+    isModelIdForProvider(stored, provider)
+  ) {
+    return stored.trim();
+  }
+  return NO_MODEL;
+}
+
 /**
  * @param {string} prefix e.g. jiraRules / githubRules
  * @param {unknown} raw
@@ -210,7 +294,9 @@ function persistable(config) {
     maxAgentTurns: config.maxAgentTurns,
     allowedTools: config.allowedTools,
     agentTimeoutMs: config.agentTimeoutMs,
+    llmProvider: isValidLlmProvider(config.llmProvider) ? config.llmProvider : 'claude',
     model: config.model,
+    lastModelsByProvider: normalizeLastModelsByProvider(config.lastModelsByProvider),
     ticketSource: config.ticketSource,
     jiraBaseUrl: config.jiraBaseUrl || '',
     jiraPrLinkPhrase: config.jiraPrLinkPhrase || 'Relates to',
@@ -250,9 +336,11 @@ export function loadConfig(repoRoot) {
     const initial = {
       ...DEFAULTS,
       allowedTools: [...KNOWN_TOOLS],
+      lastModelsByProvider: {},
       jiraRules: structuredClone(DEFAULT_JIRA_RULES),
       githubRules: structuredClone(DEFAULT_GITHUB_RULES),
     };
+    rememberModelForProvider(initial, 'claude', initial.model);
     fs.writeFileSync(configPath, JSON.stringify(persistable(initial), null, 2) + '\n', 'utf8');
     return initial;
   }
@@ -262,17 +350,31 @@ export function loadConfig(repoRoot) {
     ...DEFAULTS,
     ...raw,
     allowedTools: raw.allowedTools ?? [...KNOWN_TOOLS],
+    lastModelsByProvider: normalizeLastModelsByProvider(raw.lastModelsByProvider),
     jiraRules: normalizeJiraRules(raw.jiraRules),
     githubRules: normalizeGithubRules(raw.githubRules),
   };
 
-  if (!isValidModelId(config.model)) {
-    config.model = DEFAULT_MODEL;
+  if (isNoModel(config.model)) {
+    if (String(config.model).trim() !== NO_MODEL) {
+      config.model = NO_MODEL;
+      saveConfig(repoRoot, persistable(config));
+    } else {
+      config.model = NO_MODEL;
+    }
+  } else if (!isValidModelId(config.model)) {
+    config.model = defaultModelForProvider(
+      isValidLlmProvider(config.llmProvider) ? config.llmProvider : 'claude'
+    );
     saveConfig(repoRoot, persistable(config));
   } else {
     config.model = String(config.model).trim();
   }
 
+  if (!isValidLlmProvider(config.llmProvider)) {
+    config.llmProvider = 'claude';
+  }
+
   if (!ALLOWED_TICKET_SOURCES.has(config.ticketSource)) {
     config.ticketSource = 'github';
   }
@@ -285,6 +387,11 @@ export function loadConfig(repoRoot) {
     config.jiraPrLinkPhrase = 'Relates to';
   }
 
+  const loadedProvider = isValidLlmProvider(config.llmProvider)
+    ? config.llmProvider
+    : 'claude';
+  rememberModelForProvider(config, loadedProvider, config.model);
+
   return config;
 }
 
@@ -297,13 +404,57 @@ export function loadConfig(repoRoot) {
  * @returns {typeof DEFAULTS}
  */
 export function updateConfig(repoRoot, config, patch) {
+  if (!config.lastModelsByProvider || typeof config.lastModelsByProvider !== 'object') {
+    config.lastModelsByProvider = normalizeLastModelsByProvider(config.lastModelsByProvider);
+  }
+
+  const prevProvider = isValidLlmProvider(config.llmProvider)
+    ? config.llmProvider
+    : 'claude';
+  let providerChanged = false;
+  const willChangeProvider =
+    patch.llmProvider !== undefined &&
+    isValidLlmProvider(patch.llmProvider) &&
+    patch.llmProvider !== prevProvider;
+
+  if (willChangeProvider) {
+    rememberModelForProvider(config, prevProvider, config.model);
+  }
+
   if (patch.model != null) {
-    if (!isValidModelId(patch.model)) {
+    if (isNoModel(patch.model)) {
+      config.model = NO_MODEL;
+    } else if (!isValidModelId(patch.model)) {
       throw new Error(
-        `Invalid model "${patch.model}". Expected a non-empty Claude model id`
+        `Invalid model "${patch.model}". Expected a non-empty model id or "${NO_MODEL}" for no selection`
+      );
+    } else {
+      config.model = String(patch.model).trim();
+    }
+  }
+
+  if (patch.llmProvider !== undefined) {
+    if (!isValidLlmProvider(patch.llmProvider)) {
+      throw new Error(
+        `Invalid llmProvider "${patch.llmProvider}". Allowed: ${LLM_PROVIDERS.join(', ')}`
       );
     }
-    config.model = String(patch.model).trim();
+    providerChanged = willChangeProvider;
+    config.llmProvider = patch.llmProvider;
+  }
+
+  const currentProvider = isValidLlmProvider(config.llmProvider)
+    ? config.llmProvider
+    : 'claude';
+
+  if (providerChanged) {
+    config.model = resolveModelForProvider(config, currentProvider, config.model);
+  }
+
+  if (patch.model != null && !providerChanged) {
+    rememberModelForProvider(config, currentProvider, config.model);
+  } else if (providerChanged && !isNoModel(config.model)) {
+    rememberModelForProvider(config, currentProvider, config.model);
   }
 
   if (patch.baseBranch !== undefined) {
@@ -394,12 +545,18 @@ export function updateConfig(repoRoot, config, patch) {
  *   stubAgent?: boolean,
  *   ghAuth?: import('./gh-auth.js').GhAuthResult,
  *   claudeAuth?: import('./claude-auth.js').ClaudeAuthResult,
+ *   openrouterAuth?: import('./openrouter-auth.js').OpenRouterAuthResult,
  * }} [opts]
  */
 export function publicConfig(config, opts = {}) {
-  const model = isValidModelId(config.model)
-    ? String(config.model).trim()
-    : DEFAULT_MODEL;
+  const llmProvider = isValidLlmProvider(config.llmProvider)
+    ? config.llmProvider
+    : 'claude';
+  const model = isNoModel(config.model)
+    ? NO_MODEL
+    : isValidModelId(config.model)
+      ? String(config.model).trim()
+      : defaultModelForProvider(llmProvider);
   const repoName = opts.repoRoot ? path.basename(opts.repoRoot) : undefined;
   const ticketSource = ALLOWED_TICKET_SOURCES.has(config.ticketSource)
     ? config.ticketSource
@@ -424,13 +581,19 @@ export function publicConfig(config, opts = {}) {
 
   const ghAuth = opts.ghAuth ?? checkGhAuth();
   const claudeAuth = opts.claudeAuth ?? checkClaudeAuth();
+  const openrouterAuth = opts.openrouterAuth ?? checkOpenRouterAuth();
   const origin = originRemoteInfo(opts.repoRoot);
   const ghTokenMask = maskSecret(githubTokenFromEnv());
   const anthropicMask = maskSecret(process.env.ANTHROPIC_API_KEY);
   const claudeOauthMask = maskSecret(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+  const openrouterMask = maskSecret(process.env.OPENROUTER_API_KEY);
+
+  const curatedModels = curatedModelOptions(llmProvider);
 
   return {
+    llmProvider,
     model,
+    lastModelsByProvider: normalizeLastModelsByProvider(config.lastModelsByProvider),
     baseBranch: config.baseBranch,
     testCommand: config.testCommand ?? null,
     maxAgentTurns: config.maxAgentTurns,
@@ -438,7 +601,7 @@ export function publicConfig(config, opts = {}) {
     allowedTools: Array.isArray(config.allowedTools)
       ? [...config.allowedTools]
       : [...KNOWN_TOOLS],
-    models: MODEL_OPTIONS,
+    models: curatedModels,
     knownTools: KNOWN_TOOLS,
     ticketSource,
     jiraBaseUrl,
@@ -462,6 +625,13 @@ export function publicConfig(config, opts = {}) {
     anthropicApiKeyMasked: anthropicMask.masked,
     claudeOauthTokenSet: claudeOauthMask.set,
     claudeOauthTokenMasked: claudeOauthMask.masked,
+    openrouterAuthOk: openrouterAuth.ok === true,
+    openrouterApiKeySet: openrouterMask.set,
+    openrouterApiKeyMasked: openrouterMask.masked,
+    llmAuthOk:
+      llmProvider === 'openrouter'
+        ? openrouterAuth.ok === true
+        : claudeAuth.ok === true,
     stubAgent: opts.stubAgent === true,
     ...(repoName ? { repoName } : {}),
   };

package/src/gh-auth.js

@@ -138,21 +138,22 @@ export function checkGhAuth() {
 }
 
 /**
- * Human-readable startup error for a failed {@link checkGhAuth}.
+ * Human-readable startup warning for a failed {@link checkGhAuth}.
+ * Soft-auth: this is not fatal — the server still starts so Settings can configure auth.
  * @param {GhAuthResult} result
  */
 export function formatGhAuthError(result) {
   if (result.reason === 'not-found') {
-    return '✖ GitHub CLI (gh) not found in PATH. Install it from https://cli.github.com/';
+    return [
+      '⚠ GitHub CLI (gh) not found in PATH — server will still start.',
+      '  Install it from https://cli.github.com/, then open Settings → Authentication',
+      '  (or set GH_TOKEN in `.acdev/.env`) before enqueueing jobs.',
+    ].join('\n');
   }
   return [
-    '✖ GitHub CLI is not authenticated for github.com.',
-    '',
-    'Authenticate with one of:',
-    '  1. Interactive (browser/device): gh auth login -h github.com',
-    '  2. Personal access token: Settings → GitHub / PR auth, or set GH_TOKEN in `.acdev/.env`',
-    '  3. Non-interactive CLI: echo YOUR_PAT | gh auth login --with-token -h github.com',
-    '',
-    'SSH remotes can push/fetch git, but do not authenticate gh for issues or PRs.',
+    '⚠ GitHub is not authenticated — server will still start.',
+    '  Open Settings → Authentication to paste a PAT, or set GH_TOKEN in `.acdev/.env`.',
+    '  Or run: gh auth login -h github.com',
+    '  (SSH remotes push/fetch git but do not authenticate gh for issues/PRs.)',
   ].join('\n');
 }