@sanqianx/claude-ai-workbench 0.11.0

package/src/backend/lib/ai-profile-store.js

@@ -0,0 +1,259 @@
+const fs = require('fs');
+const path = require('path');
+const { getDataDir } = require('./data-dir');
+const { completeText } = require('./llm-client');
+
+const SCHEMA = 'ai-profiles/v1';
+const DEFAULT_TIMEOUT_MS = 300000;
+const DEFAULT_CONTEXT_WINDOW = 200000;
+
+function readJsonOrDefault(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+
+function maskSecret(value) {
+  if (!value) return '';
+  const text = String(value);
+  if (text.length <= 8) return '********';
+  return `${text.slice(0, 4)}...${text.slice(-4)}`;
+}
+
+function toPositiveInteger(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+
+function normalizeSystemPrompt(value) {
+  if (value && typeof value === 'object') return value;
+  if (typeof value === 'string' && value.trim()) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return { type: 'preset', preset: 'claude_code' };
+}
+
+function isBlankAiProfileDraft(profile) {
+  return ![
+    profile.provider,
+    profile.baseUrl,
+    profile.apiBaseUrl,
+    profile.anthropicBaseUrl,
+    profile.apiKey,
+    profile.authToken,
+    profile.anthropicAuthToken,
+    profile.mainModel,
+    profile.model,
+    profile.website,
+    profile.notes,
+  ].some(value => String(value || '').trim());
+}
+
+function profileImplementation(profile) {
+  return profile && (profile.implementation || profile.adapter || 'claude-code-agent') || 'claude-code-agent';
+}
+
+function normalizeProfilesConfig(profiles, existingCfg = { profiles: [] }, activeAiProfileId = null, options = {}) {
+  const existingById = new Map((existingCfg.profiles || []).filter(p => p && p.id).map(p => [p.id, p]));
+  const seen = new Set();
+  const normalized = [];
+  for (const raw of profiles || []) {
+    if (!raw || typeof raw !== 'object') continue;
+    const id = String(raw.id || '').trim();
+    if (id && id !== activeAiProfileId && options.dropBlankDrafts !== false && isBlankAiProfileDraft(raw)) continue;
+    if (!id) throw new Error('AI profile is missing id');
+    if (seen.has(id)) throw new Error(`duplicate AI profile id: ${id}`);
+    seen.add(id);
+    const existing = existingById.get(id) || {};
+    const provider = String(raw.provider || raw.name || existing.provider || existing.name || id).trim() || id;
+    const profile = {
+      ...existing,
+      ...raw,
+      id,
+      name: String(raw.name || raw.provider || existing.name || provider || id).trim() || id,
+      provider,
+      enabled: raw.enabled !== false,
+      implementation: 'claude-code-agent',
+      baseUrl: String(raw.baseUrl || raw.apiBaseUrl || raw.anthropicBaseUrl || '').trim(),
+      notes: String(raw.notes || '').trim(),
+      website: String(raw.website || '').trim(),
+      mainModel: String(raw.mainModel || raw.model || '').trim(),
+      thinkingModel: String(raw.thinkingModel || raw.mainModel || raw.model || '').trim(),
+      haikuModel: String(raw.haikuModel || raw.mainModel || raw.model || '').trim(),
+      sonnetModel: String(raw.sonnetModel || raw.mainModel || raw.model || '').trim(),
+      opusModel: String(raw.opusModel || raw.mainModel || raw.model || '').trim(),
+      model: String(raw.model || raw.mainModel || '').trim(),
+      timeoutMs: toPositiveInteger(raw.timeoutMs, DEFAULT_TIMEOUT_MS),
+      contextWindow: toPositiveInteger(raw.contextWindow, DEFAULT_CONTEXT_WINDOW),
+      runner: 'sdk',
+      systemPrompt: normalizeSystemPrompt(raw.systemPrompt),
+    };
+    for (const key of ['apiKey', 'authToken', 'anthropicAuthToken']) {
+      profile[key] = raw[key] ? String(raw[key]) : existing[key] || '';
+    }
+    delete profile.hasApiKey;
+    delete profile.apiKeyMasked;
+    normalized.push(profile);
+  }
+  return { schema: SCHEMA, profiles: normalized };
+}
+
+function validateProfile(profile, id = profile && profile.id) {
+  if (!id) return { ok: false, error: 'AI profile id is required' };
+  if (!profile) return { ok: false, error: `AI profile not found: ${id}` };
+  if (profile.enabled === false) return { ok: false, error: `AI profile is disabled: ${id}` };
+  if (profileImplementation(profile) !== 'claude-code-agent') {
+    return { ok: false, error: `unsupported AI implementation: ${profileImplementation(profile)}` };
+  }
+  if (!(profile.apiKey || profile.authToken || profile.anthropicAuthToken)) {
+    return { ok: false, error: `AI profile is missing API key: ${id}` };
+  }
+  if (!(profile.mainModel || profile.model)) {
+    return { ok: false, error: `AI profile is missing model: ${id}` };
+  }
+  if (!(profile.baseUrl || profile.apiBaseUrl || profile.anthropicBaseUrl)) {
+    return { ok: false, error: `AI profile is missing baseUrl: ${id}` };
+  }
+  return { ok: true, profile, implementation: profileImplementation(profile) };
+}
+
+function validateProfileConfig(cfg) {
+  const errors = [];
+  if (!cfg || typeof cfg !== 'object') return ['config must be an object'];
+  if (cfg.schema && cfg.schema !== SCHEMA) errors.push(`schema must be ${SCHEMA}`);
+  if (!Array.isArray(cfg.profiles)) errors.push('profiles must be an array');
+  const ids = new Set();
+  for (const profile of cfg.profiles || []) {
+    const id = profile && profile.id;
+    if (!id) {
+      errors.push('profile id is required');
+      continue;
+    }
+    if (ids.has(id)) errors.push(`duplicate profile id: ${id}`);
+    ids.add(id);
+    const check = validateProfile(profile, id);
+    if (!check.ok) errors.push(check.error);
+  }
+  return errors;
+}
+
+function publicProfile(profile) {
+  const secret = profile.apiKey || profile.authToken || profile.anthropicAuthToken || '';
+  return {
+    ...profile,
+    apiKey: '',
+    authToken: '',
+    anthropicAuthToken: '',
+    hasApiKey: !!secret,
+    apiKeyMasked: maskSecret(secret),
+  };
+}
+
+class AiProfileStore {
+  constructor(options = {}) {
+    this.profilesPath = options.profilesPath || path.join(getDataDir(), 'ai-profiles.json');
+    this.activeProfileId = options.activeProfileId || null;
+    this.dropBlankDrafts = options.dropBlankDrafts !== false;
+  }
+
+  readConfig() {
+    const cfg = readJsonOrDefault(this.profilesPath, { schema: SCHEMA, profiles: [] });
+    if (cfg && cfg.schema === SCHEMA && Array.isArray(cfg.profiles)) return cfg;
+    return { schema: SCHEMA, profiles: [] };
+  }
+
+  writeConfig(cfg) {
+    const normalized = normalizeProfilesConfig(
+      Array.isArray(cfg && cfg.profiles) ? cfg.profiles : [],
+      this.readConfig(),
+      cfg && (cfg.activeAiProfileId || cfg.defaultProviderId || this.activeProfileId),
+      { dropBlankDrafts: this.dropBlankDrafts }
+    );
+    const errors = validateProfileConfig(normalized);
+    if (errors.length) {
+      const err = new Error(errors[0]);
+      err.errors = errors;
+      throw err;
+    }
+    writeJson(this.profilesPath, normalized);
+    return normalized;
+  }
+
+  publicConfig() {
+    const cfg = this.readConfig();
+    const profiles = (cfg.profiles || []).map(publicProfile);
+    return {
+      ok: true,
+      aiProfilesPath: this.profilesPath,
+      config: { schema: SCHEMA, profiles },
+      profiles,
+      activeAiProfileId: this.activeProfileId || (profiles.find(p => p.enabled !== false) || {}).id || null,
+    };
+  }
+
+  profileById(id) {
+    return (this.readConfig().profiles || []).find(profile => profile && profile.id === id) || null;
+  }
+
+  firstUsableProfileId() {
+    return ((this.readConfig().profiles || []).find(profile => validateProfile(profile).ok) || {}).id || null;
+  }
+
+  activeProfile() {
+    return this.profileById(this.activeProfileId) || this.profileById(this.firstUsableProfileId());
+  }
+
+  validateProfile(idOrProfile) {
+    const profile = typeof idOrProfile === 'string' ? this.profileById(idOrProfile) : idOrProfile;
+    const id = typeof idOrProfile === 'string' ? idOrProfile : profile && profile.id;
+    return validateProfile(profile, id);
+  }
+
+  async testProfile({ profileId, profile, prompt = 'what model are you?', maxTokens = 128 } = {}) {
+    const resolved = profile || this.profileById(profileId);
+    const id = profileId || resolved && resolved.id;
+    const check = validateProfile(resolved, id);
+    if (!check.ok) {
+      const err = new Error(check.error);
+      err.status = 400;
+      throw err;
+    }
+    const result = await completeText({
+      profileId: id,
+      profile: resolved,
+      user: prompt,
+      maxTokens,
+    });
+    return {
+      ok: true,
+      profileId: id,
+      model: result.model,
+      text: result.text,
+      usage: result.usage,
+    };
+  }
+}
+
+module.exports = {
+  AiProfileStore,
+  SCHEMA,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_CONTEXT_WINDOW,
+  maskSecret,
+  publicProfile,
+  profileImplementation,
+  normalizeProfilesConfig,
+  validateProfile,
+  validateProfileConfig,
+};

package/src/backend/lib/ai-vendor-presets.js

@@ -0,0 +1,83 @@
+// Built-in vendor presets for common Anthropic-compatible providers.
+// baseUrl and model names verified against each vendor's public docs (2026-06).
+// When a user picks one of these vendor names in the profile form, all fields
+// below are auto-filled — they only need to supply an API key.
+//
+// baseUrl MUST be the /anthropic-compatible endpoint, not the OpenAI-compatible
+// one, because the runner speaks the Anthropic Messages API. Wrong path → 404.
+const AI_VENDOR_PRESETS = [
+  {
+    id: 'anthropic',
+    name: 'Anthropic Claude',
+    baseUrl: 'https://api.anthropic.com',
+    mainModel: 'claude-sonnet-4-5',
+    thinkingModel: 'claude-opus-4-7',
+    haikuModel: 'claude-haiku-4-5',
+    sonnetModel: 'claude-sonnet-4-5',
+    opusModel: 'claude-opus-4-7',
+    contextWindow: 200000,
+    website: 'https://www.anthropic.com',
+  },
+  {
+    id: 'minimax',
+    name: 'MiniMax',
+    // Domestic (China) endpoint. minimax.io is the overseas domain with a
+    // separate account system — API keys are NOT interchangeable. Domestic
+    // users register at minimaxi.com, so we default to that.
+    baseUrl: 'https://api.minimaxi.com/anthropic',
+    mainModel: 'MiniMax-M3',
+    thinkingModel: 'MiniMax-M3',
+    haikuModel: 'MiniMax-M3',
+    sonnetModel: 'MiniMax-M3',
+    opusModel: 'MiniMax-M3',
+    contextWindow: 1048576,
+    website: 'https://platform.minimaxi.com',
+  },
+  {
+    id: 'zhipu',
+    name: '智谱 GLM',
+    // Anthropic-compatible endpoint, not the OpenAI-style /api/paas/v4.
+    baseUrl: 'https://open.bigmodel.cn/api/anthropic',
+    mainModel: 'glm-4.6',
+    thinkingModel: 'glm-4.6',
+    haikuModel: 'glm-4.5-air',
+    sonnetModel: 'glm-4.6',
+    opusModel: 'glm-4.6',
+    contextWindow: 1048576,
+    website: 'https://open.bigmodel.cn',
+  },
+  {
+    id: 'deepseek',
+    name: 'DeepSeek',
+    // Anthropic-compatible endpoint at /anthropic, not the bare domain.
+    baseUrl: 'https://api.deepseek.com/anthropic',
+    mainModel: 'deepseek-chat',
+    thinkingModel: 'deepseek-reasoner',
+    haikuModel: 'deepseek-chat',
+    sonnetModel: 'deepseek-chat',
+    opusModel: 'deepseek-reasoner',
+    contextWindow: 128000,
+    website: 'https://platform.deepseek.com',
+  },
+];
+
+function listVendorPresetNames() {
+  return AI_VENDOR_PRESETS.map(v => v.name);
+}
+
+// Match by name (case-insensitive) or id (case-insensitive). Returns the
+// preset object or null. Custom vendor names that don't match return null —
+// the caller then leaves the user-typed value alone.
+function findVendorPresetByName(name) {
+  const norm = String(name || '').trim().toLowerCase();
+  if (!norm) return null;
+  return AI_VENDOR_PRESETS.find(v =>
+    v.name.toLowerCase() === norm || v.id.toLowerCase() === norm
+  ) || null;
+}
+
+module.exports = {
+  AI_VENDOR_PRESETS,
+  listVendorPresetNames,
+  findVendorPresetByName,
+};

package/src/backend/lib/ai-workspace.js

@@ -0,0 +1,140 @@
+const fs = require('fs');
+const path = require('path');
+const { getDataDir } = require('./data-dir');
+const { getWorkbenchConfig } = require('./runtime-config');
+
+const SITE_ROOT = path.resolve(__dirname, '..');
+
+function appRoot() {
+  return getDataDir();
+}
+
+function aiRoot() {
+  const cfg = getWorkbenchConfig();
+  return path.join(appRoot(), cfg.aiRootDirName || '_ai');
+}
+
+function standardSubdirs() {
+  const cfg = getWorkbenchConfig();
+  const dirs = Array.isArray(cfg.standardSubdirs) && cfg.standardSubdirs.length
+    ? cfg.standardSubdirs.slice()
+    : ['drafts', 'runs', 'context-packs', 'backups'];
+  if (cfg.sessionDirName && !dirs.includes(cfg.sessionDirName)) dirs.push(cfg.sessionDirName);
+  return dirs;
+}
+
+function safeSlug(slug) {
+  return typeof slug === 'string' && /^[a-z0-9][a-z0-9-]{0,40}$/.test(slug);
+}
+
+function projectAIPath(slug) {
+  if (!safeSlug(slug)) throw new Error(`invalid slug for AI workspace: ${slug}`);
+  return path.join(aiRoot(), slug);
+}
+
+function ensureProjectAIPath(slug) {
+  const root = projectAIPath(slug);
+  for (const sub of standardSubdirs()) {
+    fs.mkdirSync(path.join(root, sub), { recursive: true });
+  }
+  return root;
+}
+
+function legacyAIPath(kbPath) {
+  return path.join(kbPath, '_ai');
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(from, to);
+    else if (entry.isFile()) fs.copyFileSync(from, to);
+  }
+}
+
+function migrateAIWorkspace({ slug, kbPath, preserveOriginal = true }) {
+  const legacy = legacyAIPath(kbPath);
+  const target = ensureProjectAIPath(slug);
+  const result = {
+    ok: true,
+    slug,
+    legacyPath: legacy,
+    targetPath: target,
+    copied: false,
+    preservedOriginal: preserveOriginal,
+  };
+  if (!fs.existsSync(legacy)) return result;
+  copyDir(legacy, target);
+  result.copied = true;
+  if (!preserveOriginal) {
+    fs.rmSync(legacy, { recursive: true, force: true });
+    result.preservedOriginal = false;
+  }
+  return result;
+}
+
+function runPath(slug, runId) {
+  return path.join(projectAIPath(slug), 'runs', `${runId}.json`);
+}
+
+function draftDir(slug, runId) {
+  return path.join(projectAIPath(slug), 'drafts', runId);
+}
+
+function contextPackDir(slug, runId) {
+  return path.join(projectAIPath(slug), 'context-packs', runId);
+}
+
+function findExistingRunPath({ slug, kbPath, runId }) {
+  const primary = path.join(projectAIPath(slug), 'runs', `${runId}.json`);
+  return primary;
+}
+
+function findExistingDraftDir({ slug, kbPath, runId }) {
+  const primary = path.join(projectAIPath(slug), 'drafts', runId);
+  return primary;
+}
+
+function listProjectDirs(projectSlug = null, projects = null) {
+  if (projectSlug) return [projectAIPath(projectSlug)];
+  const dirs = [];
+  const root = aiRoot();
+  if (fs.existsSync(root)) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && safeSlug(entry.name)) dirs.push(path.join(root, entry.name));
+    }
+  }
+  if (projects) {
+    for (const [slug] of Object.entries(projects)) {
+      if (safeSlug(slug)) dirs.push(projectAIPath(slug));
+    }
+  }
+  return [...new Set(dirs.map(d => path.resolve(d)))];
+}
+
+const exported = {
+  SITE_ROOT,
+  appRoot,
+  aiRoot,
+  standardSubdirs,
+  projectAIPath,
+  ensureProjectAIPath,
+  legacyAIPath,
+  migrateAIWorkspace,
+  runPath,
+  draftDir,
+  contextPackDir,
+  findExistingRunPath,
+  findExistingDraftDir,
+  listProjectDirs,
+};
+
+Object.defineProperties(exported, {
+  APP_ROOT: { enumerable: true, get: appRoot },
+  AI_ROOT: { enumerable: true, get: aiRoot },
+  STANDARD_SUBDIRS: { enumerable: true, get: standardSubdirs },
+});
+
+module.exports = exported;