claude-simple 0.2.24 → 0.2.25

package/src/agent-env.js

@@ -0,0 +1,211 @@
+/**
+ * Allowlisted env for Claude Code (and Anthropic-compatible gateways
+ * such as DeepSeek). LaunchAgents do not inherit shell exports, so we
+ * persist a profile and merge ~/.claude/settings.json `env` at spawn time.
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const CLAUDE_ENV_KEYS = [
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
+  'CLAUDE_CODE_EFFORT_LEVEL',
+  'CLAUDE_MODEL',
+  'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+  'API_TIMEOUT_MS',
+  'ANTHROPIC_BETAS',
+];
+
+const SECRET_RE = /TOKEN|KEY|SECRET|PASSWORD/i;
+
+export function isSecretEnvKey(key) {
+  return SECRET_RE.test(key);
+}
+
+export function pickAllowedEnv(src) {
+  const out = {};
+  if (!src || typeof src !== 'object') return out;
+  for (const key of CLAUDE_ENV_KEYS) {
+    const v = src[key];
+    if (typeof v === 'string' && v.trim()) out[key] = v.trim();
+  }
+  return out;
+}
+
+export function mergeClaudeEnv(...layers) {
+  const out = {};
+  for (const layer of layers) {
+    if (!layer) continue;
+    Object.assign(out, pickAllowedEnv(layer));
+  }
+  return out;
+}
+
+/** Apply allowlisted keys onto a full process.env clone. */
+export function withClaudeEnv(processEnv, extra) {
+  return { ...processEnv, ...pickAllowedEnv(extra) };
+}
+
+const PLACEHOLDER_MODELS = new Set([
+  'default', 'auto', '', 'claude-sonnet-4-5', 'claude-sonnet-4-6',
+]);
+
+export function resolveClaudeModel(options, env) {
+  const requested = typeof options?.model === 'string' ? options.model.trim() : '';
+  const fromEnv = env?.ANTHROPIC_MODEL || env?.CLAUDE_MODEL || '';
+  const customGateway = !!(env?.ANTHROPIC_BASE_URL);
+  if (!requested || requested === 'default' || requested === 'auto') {
+    return fromEnv || undefined;
+  }
+  // Official fallback ids against a third-party Anthropic-compatible URL
+  // (DeepSeek etc.) would 404; prefer the env model.
+  if (customGateway && fromEnv && PLACEHOLDER_MODELS.has(requested)) {
+    return fromEnv;
+  }
+  return requested;
+}
+
+export function resolveClaudeEffort(options, env) {
+  const requested = typeof options?.effort === 'string' ? options.effort.trim() : '';
+  if (requested) return requested;
+  const fromEnv = env?.CLAUDE_CODE_EFFORT_LEVEL;
+  return fromEnv || undefined;
+}
+
+export function redactEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env || {})) {
+    if (isSecretEnvKey(k)) out[k] = { set: true, preview: maskSecret(v) };
+    else out[k] = v;
+  }
+  return out;
+}
+
+function maskSecret(v) {
+  const s = String(v);
+  if (s.length <= 8) return '••••';
+  return `${s.slice(0, 3)}…${s.slice(-4)}`;
+}
+
+export async function readSettingsJsonEnv(configDir) {
+  if (!configDir) return {};
+  const dir = String(configDir).replace(/^~/, os.homedir());
+  let acc = {};
+  for (const name of ['settings.json', 'settings.local.json']) {
+    try {
+      const raw = JSON.parse(await fs.readFile(path.join(dir, name), 'utf8'));
+      if (raw?.env && typeof raw.env === 'object') {
+        acc = { ...acc, ...pickAllowedEnv(raw.env) };
+      }
+    } catch { /* missing is fine */ }
+  }
+  return acc;
+}
+
+export function defaultAgentEnvPath() {
+  if (process.env.AGENT_ENV_FILE) return process.env.AGENT_ENV_FILE;
+  return path.join(os.homedir(), '.claude-simple-edge', 'agent-env.json');
+}
+
+export function normalizeProfileName(name) {
+  return String(name || '').trim();
+}
+
+export function parseAgentEnvDoc(raw) {
+  if (!raw || typeof raw !== 'object') return { env: {}, profiles: {} };
+  const hasProfiles = raw.profiles && typeof raw.profiles === 'object';
+  const env = pickAllowedEnv(raw.env || (!hasProfiles ? raw : {}));
+  const profiles = {};
+  if (hasProfiles) {
+    for (const [k, v] of Object.entries(raw.profiles)) {
+      const n = normalizeProfileName(k);
+      if (n) profiles[n] = pickAllowedEnv(v);
+    }
+  }
+  return { env, profiles };
+}
+
+export async function loadAgentEnvDoc(filePath = defaultAgentEnvPath()) {
+  try {
+    const raw = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    return parseAgentEnvDoc(raw);
+  } catch {
+    return { env: {}, profiles: {} };
+  }
+}
+
+export async function saveAgentEnvDoc(doc, filePath = defaultAgentEnvPath()) {
+  const env = pickAllowedEnv(doc?.env);
+  const profiles = {};
+  for (const [k, v] of Object.entries(doc?.profiles || {})) {
+    const n = normalizeProfileName(k);
+    const picked = pickAllowedEnv(v);
+    if (n && Object.keys(picked).length) profiles[n] = picked;
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const tmp = `${filePath}.tmp`;
+  await fs.writeFile(tmp, JSON.stringify({ env, profiles }, null, 2), { mode: 0o600 });
+  await fs.rename(tmp, filePath);
+  return { env, profiles };
+}
+
+/** Default (unnamed) allowlist. Named profiles live under `profiles`. */
+export async function loadAgentEnvFile(filePath = defaultAgentEnvPath()) {
+  return (await loadAgentEnvDoc(filePath)).env;
+}
+
+export async function saveAgentEnvFile(env, filePath = defaultAgentEnvPath()) {
+  const doc = await loadAgentEnvDoc(filePath);
+  doc.env = pickAllowedEnv(env);
+  await saveAgentEnvDoc(doc, filePath);
+  return doc.env;
+}
+
+/** Default layer, then workspace-named profile (same name as Settings workspace). */
+export function envForProfile(doc, name) {
+  const n = normalizeProfileName(name);
+  const named = n && doc?.profiles?.[n] ? doc.profiles[n] : {};
+  return mergeClaudeEnv(doc?.env, named);
+}
+
+/** Merge incoming PATCH: omit key to keep, empty string to delete, string to set. */
+export function patchEnv(current, patch) {
+  const out = { ...pickAllowedEnv(current) };
+  if (!patch || typeof patch !== 'object') return out;
+  for (const key of CLAUDE_ENV_KEYS) {
+    if (!(key in patch)) continue;
+    const v = patch[key];
+    if (v == null || v === '' || (typeof v === 'object' && v.set === true && !v.value)) {
+      if (v && typeof v === 'object' && v.set === true) continue; // keep secret
+      delete out[key];
+      continue;
+    }
+    if (typeof v === 'string') out[key] = v.trim();
+    else if (typeof v === 'object' && typeof v.value === 'string') out[key] = v.value.trim();
+  }
+  return out;
+}
+
+export async function applyAgentEnvToProcess(processEnv = process.env) {
+  const fileEnv = await loadAgentEnvFile();
+  const settingsEnv = await readSettingsJsonEnv(path.join(os.homedir(), '.claude'));
+  const merged = mergeClaudeEnv(processEnv, settingsEnv, fileEnv);
+  for (const [k, v] of Object.entries(merged)) processEnv[k] = v;
+  return merged;
+}
+
+export async function buildClaudeSpawnEnv({ processEnv = process.env, configDir, extra, profile } = {}) {
+  const settingsEnv = await readSettingsJsonEnv(configDir || path.join(os.homedir(), '.claude'));
+  const doc = await loadAgentEnvDoc();
+  const fileEnv = envForProfile(doc, profile);
+  const allow = mergeClaudeEnv(processEnv, settingsEnv, fileEnv, extra);
+  return { ...processEnv, ...allow };
+}

package/src/agents/claude.js

@@ -2,6 +2,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import crypto from 'crypto';
 import { mapAgentEmit, compactToolInput } from '../runtime/protocol.js';
 import { waitForApproval, cancelApprovalsForSession } from '../runtime/approvals.js';
+import { buildClaudeSpawnEnv, resolveClaudeModel, resolveClaudeEffort } from '../agent-env.js';
 
 /**
  * Run a Claude Code turn via the agent SDK.
@@ -20,7 +21,11 @@ export async function runClaude(command, options, send, { cliPath, activeSession
     sessionId: options.sessionId || null,
   });
 
-  const env = { ...process.env };
+  const env = await buildClaudeSpawnEnv({
+    processEnv: process.env,
+    configDir: options.configDir,
+    profile: options.workspaceName || options.profile,
+  });
   if (options.configDir) env.CLAUDE_CONFIG_DIR = options.configDir;
 
   const permissionMode = options.permissionMode || 'bypassPermissions';
@@ -40,12 +45,14 @@ export async function runClaude(command, options, send, { cliPath, activeSession
     tools: { type: 'preset', preset: 'claude_code' },
     systemPrompt: { type: 'preset', preset: 'claude_code' },
     settingSources: ['project', 'user', 'local'],
-    model: options.model || 'claude-sonnet-4-5',
     abortSignal: controller.signal,
   };
+  const model = resolveClaudeModel(options, env);
+  if (model) sdkOptions.model = model;
+  const effort = resolveClaudeEffort(options, env);
+  if (effort) sdkOptions.effort = effort;
   if (options.cwd) sdkOptions.cwd = options.cwd;
   if (options.sessionId) sdkOptions.resume = options.sessionId;
-  if (options.effort) sdkOptions.effort = options.effort;
   if (permissionMode && permissionMode !== 'default') {
     sdkOptions.permissionMode = permissionMode;
   }

package/src/agents/grok.js

@@ -10,6 +10,30 @@ const clients = new Map();
 const queues = new Map();
 const queueAliases = new Map();
 
+/** Read-only queue snapshot used when a browser reconnects mid-turn. The ACP
+ * process owns the real queue; exposing it lets the UI restore the user's
+ * already-accepted follow-up prompts after a page refresh. */
+export function getGrokQueueState(sessionId) {
+  const key = (sessionId && queueAliases.get(sessionId)) || sessionId;
+  const queue = key ? queues.get(key) : null;
+  if (!queue) return { running: false, items: [] };
+  return {
+    running: !!queue.running,
+    items: queue.items.map(item => String(item?.command || '')).filter(Boolean),
+  };
+}
+
+/** Drop follow-ups that have not started yet. The active ACP prompt is aborted
+ * by app.js through its active-session entry. */
+export function cancelGrokQueue(sessionId) {
+  const key = (sessionId && queueAliases.get(sessionId)) || sessionId;
+  const queue = key ? queues.get(key) : null;
+  if (!queue) return 0;
+  const count = queue.items.length;
+  queue.items.length = 0;
+  return count;
+}
+
 function profileKey(options) {
   return `${options.model || ''}\u001f${options.effort || ''}`;
 }

package/src/agents/models.js

@@ -6,6 +6,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import os from 'os';
 import { execFile } from 'child_process';
+import { pickAllowedEnv, loadAgentEnvFile, readSettingsJsonEnv } from '../agent-env.js';
 
 /** Static fallbacks when local cache/config is missing. */
 export const FALLBACK_MODELS = {
@@ -168,6 +169,34 @@ async function discoverClaude(claudeConfigDirs = []) {
   let defaultModel = null;
   const sources = [];
 
+  const envLayers = [
+    pickAllowedEnv(process.env),
+    await loadAgentEnvFile(),
+  ];
+  for (const dir of dirs) {
+    envLayers.push(await readSettingsJsonEnv(dir));
+  }
+  const envMerged = Object.assign({}, ...envLayers);
+  const envModelKeys = [
+    'ANTHROPIC_MODEL',
+    'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    'ANTHROPIC_SMALL_FAST_MODEL',
+    'CLAUDE_CODE_SUBAGENT_MODEL',
+    'CLAUDE_MODEL',
+  ];
+  for (const k of envModelKeys) {
+    const v = envMerged[k];
+    if (typeof v === 'string' && v.trim()) {
+      found.push({ value: v.trim(), label: shortLabel(v.trim()) });
+      if ((k === 'ANTHROPIC_MODEL' || k === 'CLAUDE_MODEL') && !defaultModel) {
+        defaultModel = v.trim();
+      }
+    }
+  }
+  if (found.length) sources.push('env');
+
   for (const dir of dirs) {
     for (const name of ['settings.json', 'settings.local.json']) {
       const data = await readJson(path.join(dir, name));
@@ -202,7 +231,7 @@ async function discoverClaude(claudeConfigDirs = []) {
   let models = uniqModels(found);
   let source = 'fallback';
   if (models.length) {
-    source = 'settings';
+    source = envMerged.ANTHROPIC_BASE_URL ? 'anthropic-compat' : 'settings';
     // Custom gateway / third-party models: list only what is configured
   } else {
     models = FALLBACK_MODELS.claude.models.map(m => ({ ...m }));

package/src/agents/sessions.js

@@ -1644,14 +1644,24 @@ export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codex
   return { cwd, display };
 }
 
-export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
+/**
+ * Copy a session into a new native transcript. `upTo` is an exclusive message
+ * count, used by message-level forks to copy only the selected conversation
+ * prefix. Keeping this here (rather than slicing in the browser) makes the
+ * server-owned transcript the source of truth.
+ */
+export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { upTo = null } = {}) {
   // 1. Get meta and messages from source session
   const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const cwd = meta.cwd || null;
   const display = meta.display || 'Converted Session';
   
   const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
-  const messages = bundle.messages || [];
+  let messages = bundle.messages || [];
+  if (Number.isInteger(upTo)) {
+    messages = messages.slice(0, Math.max(0, Math.min(upTo, messages.length)));
+  }
+  if (!messages.length) throw new Error('No messages available at the selected fork point');
 
   // 2. Generate target session ID
   const targetSessionId = crypto.randomUUID();