@sanqianx/claude-ai-workbench 0.11.0

package/packages/contracts/index.js

@@ -0,0 +1,295 @@
+'use strict';
+
+const API_VERSION = 'v1';
+const DEFAULT_API_PREFIX = `/api/claude-workbench/${API_VERSION}`;
+const RUNTIME = 'claude-code';
+const DEFAULT_AGENT = 'claude-code';
+const EFFORT_LEVELS = Object.freeze(['low', 'medium', 'high', 'max']);
+const PERMISSION_MODES = Object.freeze(['default', 'acceptEdits', 'plan', 'bypassPermissions']);
+const IMAGE_MEDIA_TYPES = Object.freeze(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_IMAGES_PER_MESSAGE = 20;
+const MAX_IMAGE_MESSAGE_BYTES = 20 * 1024 * 1024;
+const TEXT_MEDIA_TYPES = Object.freeze(['text/plain', 'text/markdown', 'application/json', 'text/csv']);
+const TEXT_FILE_TYPES = Object.freeze({ '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json', '.csv': 'text/csv' });
+const MAX_TEXT_BYTES = 512 * 1024;
+const MAX_ATTACHMENTS_PER_MESSAGE = MAX_IMAGES_PER_MESSAGE;
+const MAX_ATTACHMENT_MESSAGE_BYTES = MAX_IMAGE_MESSAGE_BYTES;
+
+// Capability matrix for every agent the terminal knows about. Drivers must
+// declare the same shape; the UI hides controls the active agent does not
+// support instead of failing.
+const AGENTS = Object.freeze({
+  'claude-code': Object.freeze({
+    id: 'claude-code', label: 'Claude Code', transport: 'agent-sdk',
+    authModes: Object.freeze(['profile-injected']),
+    capabilities: Object.freeze({
+      thinking: true, permissions: true, toolStream: true, images: true,
+      resume: true, modelOverride: true, generationParams: Object.freeze(['effort']),
+    }),
+  }),
+  codex: Object.freeze({
+    id: 'codex', label: 'Codex', transport: 'cli-json',
+    authModes: Object.freeze(['agent-owned', 'profile-injected']),
+    capabilities: Object.freeze({
+      thinking: false,
+      // Permission modes map to exec sandboxes (read-only/workspace-write/danger).
+      permissions: true,
+      toolStream: true, images: true,
+      resume: true, modelOverride: true,
+      // The driver maps effort to `model_reasoning_effort` (low/medium/high/xhigh).
+      generationParams: Object.freeze(['effort']),
+    }),
+  }),
+  opencode: Object.freeze({
+    id: 'opencode', label: 'OpenCode', transport: 'cli',
+    authModes: Object.freeze(['agent-owned', 'profile-injected']),
+    capabilities: Object.freeze({
+      // The CLI streams reasoning parts; the driver maps them to thinking events.
+      thinking: true,
+      permissions: true, toolStream: true, images: true,
+      resume: true, modelOverride: true, generationParams: Object.freeze([]),
+    }),
+  }),
+  zcode: Object.freeze({
+    id: 'zcode', label: 'ZCode', transport: 'cli',
+    authModes: Object.freeze(['agent-owned', 'profile-injected']),
+    capabilities: Object.freeze({
+      // The bundled zcode CLI (app-server --stdio) exists, but the terminal has
+      // no bridge driver yet; every capability stays off until one ships.
+      thinking: false, permissions: false, toolStream: false, images: false,
+      resume: false, modelOverride: false, generationParams: Object.freeze([]),
+    }),
+  }),
+});
+const AGENT_IDS = Object.freeze(Object.keys(AGENTS));
+
+const EVENT_TYPES = Object.freeze([
+  'workbench/stream-open', 'workbench/stream-reconnecting',
+  'claude/init', 'claude/state', 'claude/session-ready', 'claude/user-prompt',
+  'claude/system-prompt', 'claude/text-start', 'claude/text-delta', 'claude/result',
+  'claude/thinking-start', 'claude/thinking-delta', 'claude/tool-use', 'claude/tool-result',
+  'claude/permission-request', 'claude/permission-resolved', 'claude/usage',
+  'claude/commands', 'claude/image', 'claude/retry', 'claude/error', 'claude/stderr', 'claude/aborted',
+  'claude/selection-changed',
+]);
+
+function cleanId(value, field = 'id') {
+  const id = String(value || '').trim();
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/.test(id)) {
+    throw Object.assign(new Error(`${field} is invalid`), { status: 400 });
+  }
+  return id;
+}
+
+function normalizeContext(input = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw Object.assign(new Error('context must be an object'), { status: 400 });
+  }
+  return {
+    contextId: cleanId(input.contextId, 'contextId'),
+    contextType: input.contextType ? String(input.contextType).slice(0, 64) : undefined,
+    displayName: input.displayName ? String(input.displayName).slice(0, 256) : undefined,
+    workspaceRef: input.workspaceRef ? cleanId(input.workspaceRef, 'workspaceRef') : undefined,
+    aiProfileId: input.aiProfileId === null ? null : input.aiProfileId ? cleanId(input.aiProfileId, 'aiProfileId') : undefined,
+    model: input.model === null ? null : input.model ? String(input.model).trim().slice(0, 128) : undefined,
+    metadata: input.metadata && typeof input.metadata === 'object' && !Array.isArray(input.metadata)
+      ? input.metadata : undefined,
+  };
+}
+
+function normalizeAgentId(value) {
+  const id = String(value || DEFAULT_AGENT).trim();
+  if (!AGENTS[id]) throw Object.assign(new Error(`unknown agent: ${id}`), { status: 400 });
+  return id;
+}
+
+function normalizeEffort(value) {
+  if (value == null || value === '') return undefined;
+  const effort = String(value).trim();
+  if (!EFFORT_LEVELS.includes(effort)) {
+    throw Object.assign(new Error(`effort must be one of ${EFFORT_LEVELS.join(', ')}`), { status: 400 });
+  }
+  return effort;
+}
+
+function isAbsoluteLikePath(value) {
+  return /^([a-zA-Z]:[\\/]|\\\\|\/)/.test(String(value || ''));
+}
+
+function normalizeProject(input = {}, idOverride) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw Object.assign(new Error('project must be an object'), { status: 400 });
+  }
+  const id = cleanId(idOverride || input.id, 'projectId');
+  const name = String(input.name || '').trim().slice(0, 128);
+  if (!name) throw Object.assign(new Error('project name is required'), { status: 400 });
+  const rootPath = String(input.rootPath || '').trim();
+  if (!isAbsoluteLikePath(rootPath)) {
+    throw Object.assign(new Error('project rootPath must be an absolute local directory'), { status: 400 });
+  }
+  return {
+    id, name, rootPath,
+    ...(input.defaultAiProfileId !== undefined ? { defaultAiProfileId: input.defaultAiProfileId === null ? null : cleanId(input.defaultAiProfileId, 'defaultAiProfileId') } : {}),
+    ...(input.defaultModel !== undefined ? { defaultModel: input.defaultModel === null ? null : String(input.defaultModel).trim().slice(0, 128) || null } : {}),
+    ...(input.defaultAgentId !== undefined ? { defaultAgentId: normalizeAgentId(input.defaultAgentId) } : {}),
+    createdAt: input.createdAt || new Date().toISOString(),
+    updatedAt: input.updatedAt || input.createdAt || new Date().toISOString(),
+  };
+}
+
+function normalizeModelEntries(input) {
+  if (input == null) return [];
+  if (!Array.isArray(input)) throw Object.assign(new Error('models.list must be an array'), { status: 400 });
+  if (input.length > 100) throw Object.assign(new Error('models.list exceeds 100 entries'), { status: 400 });
+  const seen = new Set();
+  const entries = [];
+  for (const item of input) {
+    const raw = item && typeof item === 'object' && !Array.isArray(item) ? item : { id: item };
+    const id = String(raw.id || raw.model || '').trim().slice(0, 128);
+    if (!id) throw Object.assign(new Error('model entry id is required'), { status: 400 });
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const tags = Array.isArray(raw.tags)
+      ? raw.tags.map(tag => String(tag).trim().slice(0, 32)).filter(Boolean).slice(0, 8)
+      : [];
+    // Detected context windows ride along so drivers (opencode limit.context)
+    // and the capacity bubble can use them; invalid values are dropped.
+    const contextWindow = Number(raw.contextWindow);
+    const limits = Number.isFinite(contextWindow) && contextWindow > 0 && contextWindow <= 10_000_000
+      ? { contextWindow: Math.floor(contextWindow) }
+      : {};
+    entries.push({ id, openaiId: String(raw.openaiId || id.replace(/\[1m\]$/i, '')).trim().slice(0, 128), label: String(raw.label || id).slice(0, 128), tags, ...limits });
+  }
+  return entries;
+}
+
+function normalizeProfile(input = {}, idOverride) {
+  const id = cleanId(idOverride || input.id, 'profileId');
+  const models = input.models && typeof input.models === 'object' ? input.models : {};
+  const list = normalizeModelEntries(models.list);
+  const fallbackModel = list.length ? list[0].id : '';
+  const defaultModel = String(models.default || input.mainModel || input.model || fallbackModel).trim();
+  return {
+    id,
+    name: String(input.name || id).trim().slice(0, 256),
+    provider: String(input.provider || '').trim().slice(0, 128),
+    protocol: String(input.protocol || 'anthropic-compatible').trim(),
+    runtime: RUNTIME,
+    baseUrl: String(input.baseUrl || '').trim().replace(/\/+$/, ''),
+    openaiBaseUrl: resolveOpenAIBaseUrl(input),
+    credentialRef: String(input.credentialRef || input.secretId || `credential:${id}`).trim(),
+    models: {
+      default: defaultModel,
+      fast: String(models.fast || defaultModel).trim(),
+      reasoning: String(models.reasoning || defaultModel).trim(),
+      coding: String(models.coding || defaultModel).trim(),
+      largeContext: String(models.largeContext || defaultModel).trim(),
+      list,
+    },
+    contextWindow: positiveInt(input.contextWindow, 200000),
+    timeoutMs: positiveInt(input.timeoutMs, 300000),
+    permissionMode: PERMISSION_MODES.includes(input.permissionMode) ? input.permissionMode : 'default',
+    systemPrompt: normalizeSystemPrompt(input.systemPrompt),
+    enabled: input.enabled !== false,
+  };
+}
+
+function positiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function resolveOpenAIBaseUrl(profile = {}) {
+  const explicit = String(profile.openaiBaseUrl || '').trim().replace(/\/+$/, '');
+  if (explicit) return explicit;
+  const baseUrl = String(profile.baseUrl || '').trim().replace(/\/+$/, '');
+  if (profile.protocol === 'openai-compatible') return baseUrl;
+  let hostname = '';
+  try { hostname = new URL(baseUrl).hostname; } catch {}
+  if (hostname === 'api.minimax.io') return 'https://api.minimax.io/v1';
+  if (hostname === 'api.minimaxi.com' || /minimax/i.test(String(profile.provider || ''))) return 'https://api.minimaxi.com/v1';
+  return '';
+}
+
+function resolveOpenAIModel(profile = {}, model) {
+  const id = String(model || profile.mainModel || profile.models && profile.models.default || '').trim();
+  const entries = profile.models && profile.models.list;
+  const entry = Array.isArray(entries) && entries.find(item => item.id === id);
+  return String(entry && entry.openaiId || id.replace(/\[1m\]$/i, '')).trim();
+}
+
+function normalizeAttachments(input) {
+  if (input == null) return [];
+  if (!Array.isArray(input)) throw Object.assign(new Error('attachments must be an array'), { status: 400 });
+  if (input.length > MAX_ATTACHMENTS_PER_MESSAGE) throw Object.assign(new Error(`at most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments are allowed`), { status: 413 });
+  let totalBytes = 0;
+  return input.map((item, index) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) throw Object.assign(new Error(`attachment ${index + 1} is invalid`), { status: 400 });
+    const name = String(item.name || `image-${index + 1}`).replace(/[\u0000-\u001f]/g, '').slice(0, 255);
+    let mediaType = String(item.mediaType || item.mimeType || '').toLowerCase().split(';')[0].trim();
+    const isImage = IMAGE_MEDIA_TYPES.includes(mediaType);
+    if (!isImage) {
+      const extension = (name.match(/\.[^.\\/]+$/) || [''])[0].toLowerCase();
+      const textType = TEXT_FILE_TYPES[extension];
+      if (!textType || !['', 'application/octet-stream', 'text/plain', textType].includes(mediaType)) {
+        throw Object.assign(new Error(`attachment ${index + 1} has an unsupported type; use images or .txt, .md, .json, .csv files`), { status: 415 });
+      }
+      mediaType = textType;
+    }
+    const data = String(item.data || '').replace(/^data:[^;]+;base64,/, '').replace(/\s+/g, '');
+    if (!data || !/^[a-zA-Z0-9+/]+={0,2}$/.test(data) || data.length % 4 === 1 || (data.includes('=') && data.length % 4 !== 0)) throw Object.assign(new Error(`attachment ${index + 1} has invalid base64 data`), { status: 400 });
+    const size = Math.floor((data.length * 3) / 4) - (data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0);
+    const maxBytes = isImage ? MAX_IMAGE_BYTES : MAX_TEXT_BYTES;
+    if (size <= 0 || size > maxBytes) throw Object.assign(new Error(`attachment ${index + 1} exceeds ${maxBytes} bytes`), { status: 413 });
+    const bytes = Buffer.from(data, 'base64');
+    if (bytes.toString('base64').replace(/=+$/, '') !== data.replace(/=+$/, '')) throw Object.assign(new Error(`attachment ${index + 1} has invalid base64 data`), { status: 400 });
+    if (!isImage) {
+      try {
+        const content = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        if (content.includes('\u0000')) throw new Error('binary content');
+      } catch { throw Object.assign(new Error(`attachment ${index + 1} must contain UTF-8 text`), { status: 415 }); }
+    }
+    totalBytes += size;
+    if (totalBytes > MAX_ATTACHMENT_MESSAGE_BYTES) throw Object.assign(new Error(`attachment payload exceeds ${MAX_ATTACHMENT_MESSAGE_BYTES} bytes`), { status: 413 });
+    return {
+      id: item.id ? cleanId(item.id, 'attachmentId') : undefined,
+      name,
+      mediaType,
+      size,
+      width: positiveInt(item.width, 0) || undefined,
+      height: positiveInt(item.height, 0) || undefined,
+      data,
+    };
+  });
+}
+
+function normalizeImageAttachments(input) {
+  const attachments = normalizeAttachments(input);
+  if (attachments.some(item => !IMAGE_MEDIA_TYPES.includes(item.mediaType))) throw Object.assign(new Error('unsupported image type'), { status: 415 });
+  return attachments;
+}
+
+function appendTextAttachments(text, attachments = []) {
+  const blocks = attachments.filter(item => TEXT_MEDIA_TYPES.includes(item.mediaType)).map(item => {
+    const name = String(item.name).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    return `<attachment name="${name}">\n${Buffer.from(item.data, 'base64').toString('utf8')}\n</attachment>`;
+  });
+  return [String(text || ''), ...blocks].filter(Boolean).join('\n\n');
+}
+
+function normalizeSystemPrompt(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value;
+  if (typeof value === 'string' && value.trim()) return { type: 'custom', content: value };
+  return { type: 'preset', preset: 'claude_code', content: '' };
+}
+
+module.exports = {
+  API_VERSION, DEFAULT_API_PREFIX, RUNTIME, DEFAULT_AGENT, AGENTS, AGENT_IDS, EFFORT_LEVELS,
+  PERMISSION_MODES, IMAGE_MEDIA_TYPES, TEXT_MEDIA_TYPES, TEXT_FILE_TYPES,
+  MAX_IMAGE_BYTES, MAX_IMAGES_PER_MESSAGE, MAX_IMAGE_MESSAGE_BYTES, EVENT_TYPES,
+  MAX_TEXT_BYTES, MAX_ATTACHMENTS_PER_MESSAGE, MAX_ATTACHMENT_MESSAGE_BYTES,
+  cleanId, normalizeContext, normalizeProfile, normalizeProject, normalizeAgentId, normalizeEffort,
+  normalizeModelEntries, normalizeImageAttachments, normalizeAttachments, appendTextAttachments,
+  resolveOpenAIBaseUrl, resolveOpenAIModel, positiveInt,
+};

package/packages/contracts/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@claude-ai-workbench/contracts",
+  "version": "0.11.0",
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0"
+}

package/packages/core/README.md

@@ -0,0 +1,8 @@
+# @claude-ai-workbench/core
+
+Framework-neutral Claude Code terminal state machine. It owns context switching,
+session lifecycle, SSE sequence de-duplication, permission state, token usage,
+request cancellation, and resource cleanup.
+
+Most applications consume it indirectly through
+`@claude-ai-workbench/ui/claude-terminal`.

package/packages/core/index.d.ts

@@ -0,0 +1,76 @@
+import type {
+  ImageAttachmentInput,
+  PermissionMode,
+  SessionSummary,
+  SlashCommand,
+  WorkbenchContext,
+  WorkbenchEvent,
+} from "@claude-ai-workbench/contracts";
+
+export interface TerminalLine {
+  id: string;
+  at: string;
+  kind: string;
+  text?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  result?: string | null;
+  status?: string;
+  requestId?: string;
+  [key: string]: unknown;
+}
+
+export interface TerminalState {
+  context: WorkbenchContext | null;
+  contextGeneration: number;
+  sessionId: string;
+  sessions: SessionSummary[];
+  session: Partial<SessionSummary> & { state: string; connectionState: string; model: string | null; aiProfileId: string | null; turns: number };
+  lines: TerminalLine[];
+  commands: SlashCommand[];
+  commandError?: string;
+  permission: Record<string, unknown> | null;
+  permissionMode: PermissionMode;
+  tokenUsage: { used: number; total: number; hasUsage: boolean };
+  requestPending: boolean;
+  turnRunning: boolean;
+  lastSequence: number;
+  error: string | null;
+}
+
+export interface TerminalAdapter {
+  listSessions(context: WorkbenchContext, options?: Record<string, unknown>): Promise<SessionSummary[]>;
+  startSession(context: WorkbenchContext, options?: Record<string, unknown>): Promise<SessionSummary>;
+  loadSession(id: string, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+  listCommands?(id: string, options?: Record<string, unknown>): Promise<SlashCommand[]>;
+  subscribe(id: string, onEvent: (event: WorkbenchEvent) => void, onError?: (error: Error) => void, options?: Record<string, unknown>): () => void;
+  send(args: Record<string, unknown>): Promise<unknown>;
+  resolvePermission(args: Record<string, unknown>): Promise<unknown>;
+  abort(args: Record<string, unknown>): Promise<unknown>;
+  setPermissionMode(args: Record<string, unknown>): Promise<unknown>;
+  destroy?(): void;
+}
+
+export interface TerminalController {
+  readonly state: TerminalState;
+  setContext(context: WorkbenchContext | null): Promise<void>;
+  newSession(): Promise<SessionSummary>;
+  restoreSession(sessionId: string): Promise<void>;
+  send(text: string, options?: {attachments?: ImageAttachmentInput[]; [key: string]: unknown}): Promise<unknown>;
+  resolvePermission(allow: boolean, message?: string): Promise<unknown>;
+  abort(): Promise<unknown>;
+  setPermissionMode(mode: PermissionMode): Promise<unknown>;
+  setAdapter(adapter: TerminalAdapter | null): void;
+  handleEvent(event: WorkbenchEvent): void;
+  subscribeState(listener: (state: TerminalState) => void): () => void;
+  destroy(): void;
+}
+
+export declare function createState(): TerminalState;
+export declare function reduceEvent(state: TerminalState, event: WorkbenchEvent): boolean;
+export declare function createController(options?: {
+  state?: TerminalState;
+  adapter?: TerminalAdapter | null;
+  onChange?: (state: TerminalState) => void;
+  destroyAdapter?: boolean;
+}): TerminalController;

package/packages/core/index.js

@@ -0,0 +1,214 @@
+(function (global, factory) {
+  const exported = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = exported;
+  global.ClaudeWorkbenchCore = exported;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  function createState() {
+    return {
+      context: null, contextGeneration: 0, sessionId: '', sessions: [],
+      session: { state: 'idle', model: null, aiProfileId: null, turns: 0, connectionState: 'offline' },
+      lines: [], commands: [], permission: null, permissionMode: 'default',
+      tokenUsage: { used: 0, total: 200000, hasUsage: false },
+      requestPending: false, turnRunning: false, lastSequence: 0, error: null,
+    };
+  }
+
+  function text(value) {
+    if (value == null) return '';
+    if (typeof value === 'string') return value;
+    try { return JSON.stringify(value, null, 2); } catch { return String(value); }
+  }
+  function id(prefix) { return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`; }
+  function append(state, line) {
+    const next = { id: line.id || id(line.kind || 'line'), at: line.at || new Date().toISOString(), ...line };
+    state.lines.push(next);
+    if (state.lines.length > 3000) state.lines.splice(0, 300);
+    return next;
+  }
+  function find(state, lineId, kind) { return state.lines.find(item => item.id === lineId && (!kind || item.kind === kind)); }
+
+  function reduceEvent(state, event) {
+    if (!event || !event.type) return false;
+    if (event.contextId && state.context && event.contextId !== state.context.contextId) return false;
+    const sequence = Number(event.sequence || 0);
+    if (sequence && sequence <= state.lastSequence) return false;
+    if (sequence) state.lastSequence = sequence;
+    switch (event.type) {
+      case 'workbench/context-loading': state.session.connectionState = 'connecting'; state.error = null; break;
+      case 'workbench/context-ready': state.session.connectionState = 'connected'; break;
+      case 'workbench/stream-open': state.session.connectionState = 'connected'; break;
+      case 'workbench/stream-reconnecting': state.session.connectionState = 'reconnecting'; break;
+      case 'workbench/context-error':
+        state.session.connectionState = 'offline'; state.error = text(event.error || event.message);
+        append(state, { kind: 'error', text: state.error }); break;
+      case 'claude/init':
+        state.session = { ...state.session, model: event.model || state.session.model, aiProfileId: event.aiProfileId || state.session.aiProfileId, connectionState: 'connected' }; break;
+      case 'claude/state':
+        state.session.state = event.state || state.session.state;
+        state.session.turns = Number(event.turn ?? event.turns ?? state.session.turns);
+        state.turnRunning = ['running', 'thinking', 'tool-running', 'spawning'].includes(event.state); break;
+      case 'claude/session-ready':
+        state.session = { ...state.session, state: 'idle', model: event.model || state.session.model, aiProfileId: event.aiProfileId || state.session.aiProfileId, connectionState: 'connected' };
+        state.permissionMode = event.permissionMode || state.permissionMode; state.turnRunning = false; break;
+      case 'claude/user-prompt': append(state, { id: event.id, kind: 'user', text: text(event.text), attachments: Array.isArray(event.attachments) ? event.attachments : [], at: event.at }); state.turnRunning = true; break;
+      case 'claude/system-prompt': append(state, { id: event.id, kind: 'system', text: text(event.text), at: event.at }); break;
+      case 'claude/text-start': append(state, { id: event.id || event.messageId, kind: 'assistant', text: '', at: event.at }); break;
+      case 'claude/text-delta': {
+        const lineId = event.id || event.messageId; const line = find(state, lineId, 'assistant') || append(state, { id: lineId, kind: 'assistant', text: '', at: event.at });
+        line.text += text(event.text ?? event.delta); break;
+      }
+      case 'claude/result': {
+        if (!event.isError) {
+          const lineId = event.id || event.messageId; const line = find(state, lineId, 'assistant') || append(state, { id: lineId, kind: 'assistant', text: '', at: event.at });
+          line.text = text(event.result ?? event.text); state.session.turns += 1;
+        }
+        state.turnRunning = false; state.session.state = event.isError ? 'error' : 'idle'; break;
+      }
+      case 'claude/thinking-start': append(state, { id: event.id || event.messageId, kind: 'thinking', text: text(event.text || 'Thinking…'), at: event.at }); break;
+      case 'claude/thinking-delta': {
+        const lineId = event.id || event.messageId; const line = find(state, lineId, 'thinking') || append(state, { id: lineId, kind: 'thinking', text: '', at: event.at });
+        line.text += text(event.text ?? event.delta); break;
+      }
+      case 'claude/tool-use':
+        append(state, { id: event.id || event.toolUseId, kind: 'tool', name: event.name || event.toolName || 'tool', input: event.input || event.toolInput || {}, result: null, status: 'running', at: event.at });
+        state.turnRunning = true; state.session.state = 'tool-running'; break;
+      case 'claude/tool-result': {
+        const lineId = event.toolUseId || event.id; const line = find(state, lineId, 'tool');
+        if (line) { line.result = text(event.result ?? event.text ?? event.content); line.status = event.isError ? 'error' : 'done'; }
+        else append(state, { kind: 'tool-result', toolUseId: lineId, text: text(event.result ?? event.text ?? event.content), at: event.at });
+        break;
+      }
+      case 'claude/permission-request':
+        state.permission = { requestId: event.requestId || event.id, toolName: event.toolName || event.name || 'tool', input: event.input || event.toolInput || {}, message: event.message || '' };
+        append(state, { id: state.permission.requestId, kind: 'permission', name: state.permission.toolName, input: state.permission.input, text: state.permission.message, at: event.at });
+        state.turnRunning = false; state.session.state = 'pending-permission'; break;
+      case 'claude/permission-resolved': state.permission = null; state.turnRunning = Boolean(event.allow); state.session.state = event.allow ? 'running' : 'idle'; break;
+      case 'claude/usage': {
+        const usage = event.usage || event; const used = Number(event.used ?? usage.input_tokens ?? 0) + Number(usage.output_tokens || 0) + Number(usage.cache_creation_input_tokens || 0) + Number(usage.cache_read_input_tokens || 0);
+        state.tokenUsage = { used, total: Number(event.total || state.tokenUsage.total || 200000), hasUsage: true }; break;
+      }
+      case 'claude/commands': state.commands = Array.isArray(event.commands) ? event.commands : []; break;
+      case 'claude/image': append(state, { id: event.id, kind: 'image', name: event.name || 'image', mediaType: event.mediaType, url: event.url, data: event.data, at: event.at }); break;
+      case 'claude/retry': append(state, { kind: 'status', text: `Runtime retry ${event.attempt || 1}/${event.maxRetries || 3}`, at: event.at }); break;
+      case 'claude/error': case 'claude/stderr':
+        state.error = text(event.message || event.error || event.text); if (state.error) append(state, { kind: 'error', text: state.error, at: event.at });
+        state.turnRunning = false; state.session.state = 'error'; break;
+      case 'claude/aborted': append(state, { kind: 'status', text: event.message || 'Current turn aborted.', at: event.at }); state.turnRunning = false; state.session.state = 'aborted'; break;
+      default: return false;
+    }
+    return true;
+  }
+
+  function createController(options = {}) {
+    const state = options.state || createState();
+    let adapter = options.adapter || null;
+    let streamClose = null;
+    let requestController = null;
+    let destroyed = false;
+    const listeners = new Set(options.onChange ? [options.onChange] : []);
+
+    const notify = () => { if (!destroyed) for (const listener of listeners) try { listener(state); } catch {} };
+    const emit = event => { const changed = reduceEvent(state, event); if (changed) notify(); };
+    const closeStream = () => { if (streamClose) try { streamClose(); } catch {} streamClose = null; };
+    const cancelRequest = () => { if (requestController) requestController.abort(); requestController = null; };
+    function reset() {
+      state.sessionId = ''; state.sessions = []; state.lines = []; state.commands = []; state.permission = null;
+      state.tokenUsage = { used: 0, total: 200000, hasUsage: false };
+      state.session = { state: 'idle', model: null, aiProfileId: state.context && state.context.aiProfileId || null, turns: 0, connectionState: 'offline' };
+      state.requestPending = false; state.turnRunning = false; state.lastSequence = 0; state.error = null;
+    }
+    function subscribe(sessionId, generation) {
+      closeStream();
+      streamClose = adapter.subscribe(sessionId, event => {
+        if (destroyed || generation !== state.contextGeneration || sessionId !== state.sessionId) return;
+        emit(event);
+      }, () => {
+        if (!destroyed && generation === state.contextGeneration) emit({ type: 'workbench/stream-reconnecting' });
+      }, { afterSequence: state.lastSequence });
+    }
+    async function loadSession(sessionId, generation, signal) {
+      const snapshot = await adapter.loadSession(sessionId, { signal });
+      if (destroyed || generation !== state.contextGeneration) return;
+      state.sessionId = sessionId;
+      state.session = { ...state.session, ...(snapshot.session || {}), connectionState: 'connected' };
+      state.lines = []; state.lastSequence = 0;
+      for (const event of snapshot.events || []) reduceEvent(state, event);
+      state.permission = snapshot.permission || null;
+      state.permissionMode = snapshot.permissionMode || state.permissionMode;
+      state.tokenUsage = snapshot.tokenUsage || state.tokenUsage;
+      subscribe(sessionId, generation); notify();
+      if (typeof adapter.listCommands === 'function') {
+        try {
+          const commands = await adapter.listCommands(sessionId, { signal });
+          if (!destroyed && generation === state.contextGeneration && sessionId === state.sessionId) {
+            state.commands = Array.isArray(commands) ? commands : [];
+            notify();
+          }
+        } catch (error) {
+          if (!(error && error.name === 'AbortError') && generation === state.contextGeneration) {
+            state.commandError = text(error);
+            notify();
+          }
+        }
+      }
+    }
+    async function setContext(input) {
+      if (destroyed) return;
+      const next = input ? { ...input, contextId: input.contextId || input.projectId } : null;
+      if (state.context && next && state.context.contextId === next.contextId) { state.context = { ...state.context, ...next }; notify(); return; }
+      state.contextGeneration += 1;
+      const generation = state.contextGeneration;
+      closeStream(); cancelRequest(); requestController = new AbortController();
+      state.context = next; reset(); emit({ type: 'workbench/context-loading' });
+      if (!next || !next.contextId) { emit({ type: 'workbench/context-ready' }); return; }
+      if (!adapter) { emit({ type: 'workbench/context-error', error: 'Claude Workbench client is not configured.' }); return; }
+      try {
+        state.sessions = await adapter.listSessions(next, { signal: requestController.signal });
+        if (destroyed || generation !== state.contextGeneration) return;
+        let active = state.sessions.find(item => item.active) || state.sessions[0];
+        if (!active) { active = await adapter.startSession(next, { signal: requestController.signal, permissionMode: state.permissionMode }); state.sessions.unshift(active); }
+        await loadSession(active.sessionId, generation, requestController.signal);
+        emit({ type: 'workbench/context-ready' });
+      } catch (error) {
+        if (error && error.name === 'AbortError') return;
+        if (generation === state.contextGeneration) emit({ type: 'workbench/context-error', error });
+      }
+    }
+    async function newSession() {
+      if (!adapter || !state.context) throw new Error('No active context');
+      const session = await adapter.startSession(state.context, { permissionMode: state.permissionMode });
+      state.sessions = [session, ...state.sessions.filter(item => item.sessionId !== session.sessionId)];
+      await loadSession(session.sessionId, state.contextGeneration); return session;
+    }
+    async function restoreSession(sessionId) { await loadSession(sessionId, state.contextGeneration); }
+    async function send(value, options) {
+      const message = String(value || '').trim();
+      const attachments = options && Array.isArray(options.attachments) ? options.attachments : [];
+      if (!message && !attachments.length) return;
+      if (!state.sessionId) await newSession();
+      state.requestPending = true; notify();
+      try {
+        const sendOptions = { ...(options || {}) }; delete sendOptions.attachments;
+        return await adapter.send({ sessionId: state.sessionId, context: state.context, text: message, attachments, options: sendOptions });
+      }
+      finally { state.requestPending = false; notify(); }
+    }
+    async function resolvePermission(allow, message) {
+      if (!state.permission) return;
+      return adapter.resolvePermission({ sessionId: state.sessionId, requestId: state.permission.requestId, allow: allow === true, message: message || '' });
+    }
+    async function abort() { if (state.sessionId) return adapter.abort({ sessionId: state.sessionId }); }
+    async function setPermissionMode(mode) { state.permissionMode = mode || 'default'; notify(); if (state.sessionId) return adapter.setPermissionMode({ sessionId: state.sessionId, mode: state.permissionMode }); }
+    function destroy() { destroyed = true; closeStream(); cancelRequest(); listeners.clear(); if (options.destroyAdapter && adapter && adapter.destroy) adapter.destroy(); }
+    return {
+      state, setContext, newSession, restoreSession, send, resolvePermission, abort, setPermissionMode,
+      setAdapter(value) { adapter = value; }, handleEvent: emit,
+      subscribeState(listener) { listeners.add(listener); listener(state); return () => listeners.delete(listener); },
+      destroy,
+    };
+  }
+
+  return { createState, reduceEvent, createController };
+});

package/packages/core/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@claude-ai-workbench/core",
+  "version": "0.11.0",
+  "type": "commonjs",
+  "main": "index.js",
+  "browser": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./index.js",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "dependencies": {
+    "@claude-ai-workbench/contracts": "0.11.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0"
+}