@sanqianx/claude-ai-workbench 0.11.0

package/packages/server/lib/profile-store.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const path = require('path');
+const { normalizeProfile, cleanId } = require('../../contracts');
+const { readJson, writeJson } = require('./json-file');
+
+class ProfileStore {
+  constructor(options = {}) {
+    if (!options.dataDir) throw new Error('ProfileStore dataDir is required');
+    this.profileFile = options.profileFile || path.join(options.dataDir, 'profiles.v2.json');
+    this.credentialFile = options.credentialFile || path.join(options.dataDir, 'credentials.v1.json');
+  }
+
+  _profiles() { return readJson(this.profileFile, { schema: 'claude-workbench-profiles/v2', profiles: [] }); }
+  _credentials() { return readJson(this.credentialFile, { schema: 'claude-workbench-credentials/v1', credentials: {} }); }
+
+  _configured(profile) {
+    return Boolean(this._credentials().credentials[profile.credentialRef]);
+  }
+
+  publicProfile(profile) {
+    profile = normalizeProfile(profile);
+    const secret = this._credentials().credentials[profile.credentialRef] || '';
+    const clean = {
+      ...profile,
+      credentialConfigured: Boolean(secret),
+      credentialMasked: maskCredential(secret),
+    };
+    delete clean.apiKey;
+    delete clean.authToken;
+    delete clean.anthropicAuthToken;
+    delete clean.secret;
+    return clean;
+  }
+
+  list() { return this._profiles().profiles.map(profile => this.publicProfile(profile)); }
+
+  get(id) {
+    const profileId = cleanId(id, 'profileId');
+    const profile = this._profiles().profiles.find(item => item.id === profileId);
+    return profile ? this.publicProfile(profile) : null;
+  }
+
+  save(input, idOverride) {
+    const profile = normalizeProfile(input, idOverride);
+    validateProfile(profile);
+    const cfg = this._profiles();
+    const index = cfg.profiles.findIndex(item => item.id === profile.id);
+    if (index >= 0) cfg.profiles[index] = profile;
+    else cfg.profiles.push(profile);
+    writeJson(this.profileFile, cfg);
+    return this.publicProfile(profile);
+  }
+
+  delete(id) {
+    const profileId = cleanId(id, 'profileId');
+    const cfg = this._profiles();
+    const profile = cfg.profiles.find(item => item.id === profileId);
+    if (!profile) return false;
+    cfg.profiles = cfg.profiles.filter(item => item.id !== profileId);
+    writeJson(this.profileFile, cfg);
+    const secrets = this._credentials();
+    delete secrets.credentials[profile.credentialRef];
+    writeJson(this.credentialFile, secrets);
+    return true;
+  }
+
+  setCredential(id, credential) {
+    const profileId = cleanId(id, 'profileId');
+    const cfg = this._profiles();
+    const profile = cfg.profiles.find(item => item.id === profileId);
+    if (!profile) throw Object.assign(new Error('profile not found'), { status: 404 });
+    const secret = typeof credential === 'string' ? credential : credential && credential.secret;
+    if (!secret || typeof secret !== 'string') {
+      throw Object.assign(new Error('credential secret is required'), { status: 400 });
+    }
+    const secrets = this._credentials();
+    secrets.credentials[profile.credentialRef] = String(secret);
+    writeJson(this.credentialFile, secrets);
+  }
+
+  runtimeProfile(id) {
+    const profileId = cleanId(id, 'profileId');
+    const profile = this._profiles().profiles.find(item => item.id === profileId);
+    if (!profile) throw Object.assign(new Error('profile not found'), { status: 404 });
+    if (!profile.enabled) throw Object.assign(new Error('profile is disabled'), { status: 400 });
+    const secret = this._credentials().credentials[profile.credentialRef];
+    if (!secret) throw Object.assign(new Error('profile credential is not configured'), { status: 400 });
+    return runtimeShape(profile, secret);
+  }
+
+  runtimeDraft(input, credential, options = {}) {
+    const profile = normalizeProfile(input);
+    validateProfile(profile, options);
+    if (!profile.enabled) throw Object.assign(new Error('profile is disabled'), { status: 400 });
+    let secret = typeof credential === 'string' ? credential : credential && credential.secret;
+    if (!secret) {
+      const saved = this._profiles().profiles.find(item => item.id === profile.id);
+      if (saved) secret = this._credentials().credentials[saved.credentialRef];
+    }
+    if (!secret) throw Object.assign(new Error('profile credential is not configured'), { status: 400 });
+    return runtimeShape(profile, String(secret));
+  }
+}
+
+function runtimeShape(profile, secret) {
+  profile = normalizeProfile(profile);
+  return {
+    ...profile,
+    apiKey: secret,
+    mainModel: profile.models.default,
+    thinkingModel: profile.models.reasoning || profile.models.default,
+    haikuModel: profile.models.fast || profile.models.default,
+    sonnetModel: profile.models.coding || profile.models.default,
+    opusModel: profile.models.largeContext || profile.models.default,
+  };
+}
+
+function maskCredential(secret) {
+  const value = String(secret || '');
+  if (!value) return '';
+  if (value.length <= 12) return `${value.slice(0, 2)}****${value.slice(-2)}`;
+  return `${value.slice(0, 6)}****${value.slice(-6)}`;
+}
+
+function validateProfile(profile, options = {}) {
+  if (profile.runtime !== 'claude-code') throw Object.assign(new Error('runtime must be claude-code'), { status: 400 });
+  if (!profile.provider) throw Object.assign(new Error('provider is required'), { status: 400 });
+  // One protocol endpoint is enough: single-protocol providers are valid;
+  // the agents that speak the missing protocol simply can't use it.
+  if (!profile.baseUrl && !profile.openaiBaseUrl) {
+    throw Object.assign(new Error('baseUrl is required'), { status: 400 });
+  }
+  for (const field of ['baseUrl', 'openaiBaseUrl']) {
+    if (!profile[field]) continue;
+    let url;
+    try { url = new URL(profile[field]); } catch {}
+    if (!url || !['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+      throw Object.assign(new Error(`${field} must be an HTTP(S) endpoint without credentials, query, or fragment`), { status: 400 });
+    }
+  }
+  // Detection runs before any model is configured; every other path needs one.
+  if (!profile.models.default && options.requireModel !== false) {
+    throw Object.assign(new Error('models.default is required'), { status: 400 });
+  }
+  return profile;
+}
+
+module.exports = { ProfileStore, validateProfile, maskCredential };

package/packages/server/lib/project-store.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { normalizeProject } = require('../../contracts');
+const { readJson, writeJson } = require('./json-file');
+
+const SCHEMA = 'agent-terminal-projects/v1';
+
+// Registry of user-created workspaces. Each project binds a display name to
+// an absolute local directory; its projectId doubles as the ContextResolver
+// workspaceRef so sessions inherit project ownership for free.
+class ProjectStore {
+  constructor(options = {}) {
+    if (!options.dataDir) throw new Error('ProjectStore dataDir is required');
+    this.projectFile = options.projectFile || path.join(options.dataDir, 'projects.v1.json');
+  }
+
+  _read() { return readJson(this.projectFile, { schema: SCHEMA, projects: [] }); }
+  _write(cfg) { writeJson(this.projectFile, cfg); }
+
+  list() {
+    return this._read().projects
+      .slice()
+      .sort((a, b) => String(a.createdAt).localeCompare(String(b.createdAt)));
+  }
+
+  get(id) {
+    return this._read().projects.find(item => item.id === id) || null;
+  }
+
+  create(input = {}) {
+    const cfg = this._read();
+    const rootPath = resolveExistingDirectory(input.rootPath);
+    const project = normalizeProject({ ...input, rootPath }, generateProjectId(cfg));
+    cfg.projects.push(project);
+    this._write(cfg);
+    return project;
+  }
+
+  rename(id, name) {
+    return this.update(id, { name });
+  }
+
+  update(id, input = {}) {
+    const cfg = this._read();
+    const index = cfg.projects.findIndex(item => item.id === id);
+    if (index < 0) throw Object.assign(new Error('project not found'), { status: 404 });
+    const current = cfg.projects[index];
+    const next = normalizeProject({
+      ...current,
+      ...Object.fromEntries(['name', 'defaultAiProfileId', 'defaultModel', 'defaultAgentId']
+        .filter(key => Object.prototype.hasOwnProperty.call(input, key)).map(key => [key, input[key]])),
+      rootPath: current.rootPath, createdAt: current.createdAt,
+    }, current.id);
+    next.updatedAt = new Date().toISOString();
+    cfg.projects[index] = next;
+    this._write(cfg);
+    return next;
+  }
+
+  remove(id) {
+    const cfg = this._read();
+    if (!cfg.projects.some(item => item.id === id)) return false;
+    cfg.projects = cfg.projects.filter(item => item.id !== id);
+    this._write(cfg);
+    return true;
+  }
+
+  toWorkspaceMap() {
+    const map = {};
+    for (const project of this.list()) map[project.id] = project.rootPath;
+    return map;
+  }
+}
+
+function generateProjectId(cfg) {
+  const taken = new Set(cfg.projects.map(item => item.id));
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const id = `prj-${crypto.randomBytes(5).toString('hex')}`;
+    if (!taken.has(id)) return id;
+  }
+  throw new Error('unable to allocate a project id');
+}
+
+function resolveExistingDirectory(rootPath) {
+  const value = String(rootPath || '').trim();
+  if (!value) throw Object.assign(new Error('project rootPath is required'), { status: 400 });
+  let real;
+  try {
+    real = fs.realpathSync(path.resolve(value));
+  } catch {
+    throw Object.assign(new Error(`project directory does not exist: ${value}`), { status: 400 });
+  }
+  if (!fs.statSync(real).isDirectory()) {
+    throw Object.assign(new Error(`project rootPath is not a directory: ${value}`), { status: 400 });
+  }
+  return real;
+}
+
+module.exports = { ProjectStore };

package/packages/server/lib/session-archive-store.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const path = require('path');
+const { readJson, writeJson } = require('./json-file');
+
+const SCHEMA = 'agent-terminal-session-archive/v1';
+
+// Sidecar marking sessions the user archived. Session records themselves stay
+// owned by the runner, so archiving never rewrites runner history — it only
+// flips visibility in listings and can be undone at any time.
+class SessionArchiveStore {
+  constructor(options = {}) {
+    if (!options.dataDir) throw new Error('SessionArchiveStore dataDir is required');
+    this.archiveFile = options.archiveFile || path.join(options.dataDir, 'archived-sessions.v1.json');
+  }
+
+  _read() { return readJson(this.archiveFile, { schema: SCHEMA, sessions: {} }); }
+  _write(cfg) { writeJson(this.archiveFile, cfg); }
+
+  isArchived(sessionId) { return Boolean(this._read().sessions[sessionId]); }
+  // Marks older than maxAgeMs. Entries without a parseable archivedAt never
+  // expire — deleting what cannot be dated is not a safe default.
+  expired(maxAgeMs, now = Date.now()) {
+    const cfg = this._read();
+    const ids = [];
+    for (const [sessionId, meta] of Object.entries(cfg.sessions)) {
+      const archivedAt = Date.parse(meta && meta.archivedAt);
+      if (Number.isFinite(archivedAt) && now - archivedAt > maxAgeMs) ids.push(sessionId);
+    }
+    return ids;
+  }
+
+  archive(sessionId) {
+    const cfg = this._read();
+    if (!cfg.sessions[sessionId]) {
+      cfg.sessions[sessionId] = { archivedAt: new Date().toISOString() };
+      this._write(cfg);
+    }
+    return cfg.sessions[sessionId];
+  }
+
+  restore(sessionId) {
+    const cfg = this._read();
+    if (!cfg.sessions[sessionId]) return false;
+    delete cfg.sessions[sessionId];
+    this._write(cfg);
+    return true;
+  }
+
+  forget(sessionId) { this.restore(sessionId); }
+}
+
+module.exports = { SessionArchiveStore };

package/packages/server/lib/system-doctor.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Environment diagnostics behind GET /system/doctor. Everything a fresh
+// machine needs to explain "discovery showed the agent but turns failed":
+// resolved executables, live version probes, login-state files — no secrets.
+function createSystemDoctor(deps = {}) {
+  const resolveClaudeExecutable = deps.resolveClaudeExecutable || (() => ({ cmd: null }));
+  const discoverZCodeCli = deps.discoverZCodeCli || (() => null);
+  const probeZCodeVersion = deps.probeZCodeVersion || (() => null);
+  const doSpawnSync = deps.spawnSyncImpl || spawnSync;
+  const env = deps.env || process.env;
+  const platform = deps.platform || process.platform;
+
+  function probe(command, args) {
+    try {
+      const result = doSpawnSync(command, args, {
+        timeout: 10000,
+        windowsHide: true,
+        encoding: 'utf8',
+        shell: platform === 'win32',
+        env,
+      });
+      if (result.error) {
+        return { ok: false, error: String(result.error.message || result.error).slice(0, 200) };
+      }
+      const text = String(result.stdout || result.stderr || '').trim();
+      if (result.status !== 0) {
+        return { ok: false, exitCode: result.status, error: text.slice(0, 200) || `exit ${result.status}` };
+      }
+      const match = text.match(/(\d+\.\d+[\w.-]*)/);
+      return { ok: true, version: match ? match[1] : text.split(/\r?\n/)[0].slice(0, 64) || null };
+    } catch (error) {
+      return { ok: false, error: String(error && error.message || error).slice(0, 200) };
+    }
+  }
+
+  function fileState(file) {
+    try {
+      const stat = fs.statSync(file);
+      return { exists: true, sizeBytes: stat.size };
+    } catch {
+      return { exists: false };
+    }
+  }
+
+  function zcodeLoginState() {
+    const home = os.homedir();
+    const config = path.join(home, '.zcode', 'v2', 'config.json');
+    const state = { config: fileState(config), providers: [] };
+    if (!state.config.exists) return state;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(config, 'utf8'));
+      const scan = (node) => {
+        if (!node || typeof node !== 'object') return;
+        for (const [key, value] of Object.entries(node)) {
+          if (/provider|coding|glm|anthropic|openai/i.test(key) && value && typeof value === 'object') {
+            state.providers.push(key);
+          } else if (typeof value === 'object') {
+            scan(value);
+          }
+        }
+      };
+      scan(parsed);
+    } catch (error) {
+      state.parseError = String(error && error.message || error).slice(0, 120);
+    }
+    return state;
+  }
+
+  function claudeLoginState() {
+    const home = os.homedir();
+    return {
+      claudeJson: fileState(path.join(home, '.claude.json')),
+      claudeDir: fileState(path.join(home, '.claude')),
+      execPathOverride: env.CLAUDE_CODE_EXECPATH || null,
+    };
+  }
+
+  return function doctor() {
+    const claude = resolveClaudeExecutable() || {};
+    const claudeProbe = claude.cmd
+      ? probe(claude.cmd, ['--version'])
+      : { ok: false, error: claude.reason || 'no executable resolved' };
+    const zcode = discoverZCodeCli();
+    const report = {
+      schema: 'agent-terminal-doctor/v1',
+      at: new Date().toISOString(),
+      environment: {
+        node: process.version,
+        platform,
+        arch: process.arch,
+        cwd: process.cwd(),
+      },
+      agents: {
+        'claude-code': {
+          resolvedExecutable: claude.cmd || null,
+          resolutionReason: claude.cmd ? null : (claude.reason || 'not found'),
+          versionProbe: claudeProbe,
+          loginState: claudeLoginState(),
+        },
+        codex: { versionProbe: probe('codex', ['--version']) },
+        opencode: { versionProbe: probe('opencode', ['--version']) },
+        zcode: {
+          cli: zcode ? { path: zcode.path, source: zcode.source || null } : null,
+          versionProbe: zcode ? probe(process.execPath, [zcode.path, '--version']) : { ok: false, error: 'CLI not discovered' },
+          loginState: zcodeLoginState(),
+        },
+      },
+    };
+    return report;
+  };
+}
+
+module.exports = { createSystemDoctor };

package/packages/server/lib/ui-preferences-store.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const path = require('path');
+const { readJson, writeJson } = require('./json-file');
+
+const SCHEMA = 'agent-terminal-ui-preferences/v1';
+
+// Last-used composer selector values (protection mode, model, effort, agent).
+// The UI loads them on boot and stores every user-driven change back, so the
+// selections survive conversation/project switches and full restarts. Only
+// whitelisted string keys are kept, so a stale or hostile payload cannot
+// smuggle arbitrary state into the renderer.
+const ALLOWED_KEYS = ['permissionMode', 'effort', 'currentAgent', 'currentProfileId', 'currentModel'];
+
+class UiPreferencesStore {
+  constructor(options = {}) {
+    if (!options.dataDir) throw new Error('UiPreferencesStore dataDir is required');
+    this.preferencesFile = options.preferencesFile || path.join(options.dataDir, 'ui-preferences.v1.json');
+  }
+
+  read() {
+    const cfg = readJson(this.preferencesFile, { schema: SCHEMA, values: {} });
+    return { schema: SCHEMA, values: this._clean(cfg.values || {}) };
+  }
+
+  save(input = {}) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+      throw Object.assign(new Error('ui preferences must be an object'), { status: 400 });
+    }
+    const values = { ...this.read().values, ...this._clean(input) };
+    const cfg = { schema: SCHEMA, values, updatedAt: new Date().toISOString() };
+    writeJson(this.preferencesFile, cfg);
+    return { schema: SCHEMA, values };
+  }
+
+  _clean(input) {
+    const values = {};
+    for (const key of ALLOWED_KEYS) {
+      if (input[key] === undefined) continue;
+      if (input[key] !== null && typeof input[key] !== 'string') continue;
+      if (typeof input[key] === 'string' && input[key].length > 200) continue;
+      values[key] = input[key];
+    }
+    return values;
+  }
+}
+
+module.exports = { UiPreferencesStore, SCHEMA };