claude-simple 0.2.23 → 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,10 +10,64 @@ 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 || ''}`;
 }
 
+// JSON-RPC 2.0 error.code must be an integer. Node fs/spawn errors use string
+// codes like "ENOENT"; Grok's Rust client rejects those and logs
+// `invalid type: string "ENOENT", expected i32`.
+export function jsonRpcErrorCode(error) {
+  const code = error?.code;
+  if (typeof code === 'number' && Number.isInteger(code)) return code;
+  return -32000;
+}
+
+/** ACP paths must be absolute; resolve relatives against the session cwd, not the edge process cwd. */
+export function resolveFsPath(filePath, cwd) {
+  const raw = String(filePath || '').trim();
+  if (!raw) {
+    const err = new Error('path is required');
+    err.code = -32602;
+    throw err;
+  }
+  return path.resolve(cwd || process.cwd(), raw);
+}
+
+export function selectPermissionOption(options) {
+  const list = Array.isArray(options) ? options : [];
+  const allow = list.find(o => o?.kind === 'allow_always')
+    || list.find(o => o?.kind === 'allow_once')
+    || list.find(o => typeof o?.kind === 'string' && String(o.kind).startsWith('allow'))
+    || list[0];
+  if (!allow?.optionId) return { outcome: 'cancelled' };
+  return { outcome: 'selected', optionId: allow.optionId };
+}
+
 function envFromParams(envList) {
   const env = { ...process.env };
   if (!Array.isArray(envList)) return env;
@@ -164,6 +218,7 @@ class GrokACPClient {
     this.child = spawn(cliPath || 'grok', args, { stdio: ['pipe', 'pipe', 'pipe'] });
     this.pending = new Map();
     this.listeners = new Map();
+    this.sessionCwd = new Map();
     // High ids avoid colliding with agent-originated request ids (often 0..N).
     this.nextID = 100000;
     this.terminals = new TerminalHost();
@@ -198,13 +253,19 @@ class GrokACPClient {
     return init;
   }
 
+  fsCwd(params) {
+    return (params?.sessionId && this.sessionCwd.get(params.sessionId)) || process.cwd();
+  }
+
   async handleClientRequest(msg) {
     const method = msg.method;
     const params = msg.params || {};
     try {
       let result = {};
-      if (method === 'fs/read_text_file') {
-        const filePath = String(params.path || '');
+      if (method === 'session/request_permission') {
+        result = { outcome: selectPermissionOption(params.options) };
+      } else if (method === 'fs/read_text_file') {
+        const filePath = resolveFsPath(params.path, this.fsCwd(params));
         const content = await fs.promises.readFile(filePath, 'utf8');
         const limit = Number.isFinite(params.limit) ? params.limit : null;
         const line = Number.isFinite(params.line) ? params.line : null;
@@ -217,11 +278,13 @@ class GrokACPClient {
           result = { content };
         }
       } else if (method === 'fs/write_text_file') {
-        const filePath = String(params.path || '');
+        const filePath = resolveFsPath(params.path, this.fsCwd(params));
+        const content = params.content == null ? '' : String(params.content);
         await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.promises.writeFile(filePath, params.content ?? '', 'utf8');
+        await fs.promises.writeFile(filePath, content, 'utf8');
         result = {};
       } else if (method === 'terminal/create') {
+        if (!params.cwd) params = { ...params, cwd: this.fsCwd(params) };
         result = this.terminals.create(params);
       } else if (method === 'terminal/output') {
         result = this.terminals.output(params.terminalId);
@@ -244,7 +307,10 @@ class GrokACPClient {
       this.write({
         jsonrpc: '2.0',
         id: msg.id,
-        error: { code: error.code || -32000, message: error.message || 'Client request failed' },
+        error: {
+          code: jsonRpcErrorCode(error),
+          message: error.message || 'Client request failed',
+        },
       });
     }
   }
@@ -291,20 +357,23 @@ class GrokACPClient {
 
   async ensureSession(options) {
     await this.ready;
+    const cwd = options.cwd || process.cwd();
     if (options.sessionId) {
       try {
-        await this.request('session/load', { sessionId: options.sessionId, cwd: options.cwd, mcpServers: [] });
+        await this.request('session/load', { sessionId: options.sessionId, cwd, mcpServers: [] });
       } catch {
-        await this.request('session/resume', { sessionId: options.sessionId, cwd: options.cwd, mcpServers: [] });
+        await this.request('session/resume', { sessionId: options.sessionId, cwd, mcpServers: [] });
       }
+      this.sessionCwd.set(options.sessionId, cwd);
       return options.sessionId;
     }
     const result = await this.request('session/new', {
-      cwd: options.cwd || process.cwd(),
+      cwd,
       mcpServers: [],
       _meta: { yoloMode: true },
     });
     if (!result.sessionId) throw new Error('Grok ACP did not return a session id');
+    this.sessionCwd.set(result.sessionId, cwd);
     return result.sessionId;
   }
 }

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

@@ -910,12 +910,16 @@ function geminiJournalPath(sessionId, geminiHome) {
   return path.join(geminiUiSessionsRoot(geminiHome), `${sessionId}.jsonl`);
 }
 
-// agy keeps the actual native transcript here.  This is plain JSONL (unlike
-// its conversation SQLite database) and is available for conversations made
-// in the Antigravity app as well as print-mode conversations created by us.
-function geminiNativeTranscriptPath(sessionId, geminiHome) {
+// agy keeps both a compact transport log and a lossless transcript.  The
+// compact log replaces large fields with `<truncated N bytes>`; always prefer
+// the full file when it is available so chat history never loses message text.
+function geminiNativeTranscriptPaths(sessionId, geminiHome) {
   const home = geminiHome || path.join(os.homedir(), '.gemini');
-  return path.join(home, 'antigravity-cli', 'brain', sessionId, '.system_generated', 'logs', 'transcript.jsonl');
+  const logs = path.join(home, 'antigravity-cli', 'brain', sessionId, '.system_generated', 'logs');
+  return [
+    path.join(logs, 'transcript_full.jsonl'),
+    path.join(logs, 'transcript.jsonl'),
+  ];
 }
 
 function geminiPathFromUri(uri) {
@@ -1039,8 +1043,10 @@ async function findGeminiJournal(sessionId, geminiHome) {
 }
 
 async function findGeminiNativeTranscript(sessionId, geminiHome) {
-  const file = geminiNativeTranscriptPath(sessionId, geminiHome);
-  try { await fs.access(file); return file; } catch { return null; }
+  for (const file of geminiNativeTranscriptPaths(sessionId, geminiHome)) {
+    try { await fs.access(file); return file; } catch { /* try the compact fallback */ }
+  }
+  return null;
 }
 
 function geminiUserText(content) {
@@ -1571,7 +1577,8 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   let file;
   if (a === 'codex') file = await findCodexSessionFile(sessionId, codexHome);
   else if (a === 'cursor') file = await findCursorJournal(sessionId, cursorHome);
-  else if (a === 'gemini') file = await findGeminiJournal(sessionId, geminiHome);
+  else if (a === 'gemini') file = await findGeminiNativeTranscript(sessionId, geminiHome)
+    || await findGeminiJournal(sessionId, geminiHome);
   else if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     file = dir ? path.join(dir, 'chat_history.jsonl') : null;
@@ -1637,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();