@sanqianx/claude-ai-workbench 0.13.2 → 0.13.4

package/packages/server/lib/drivers/zcode-profile-runtime.js

@@ -1,71 +1,71 @@
-'use strict';
-const http = require('node:http');
-const https = require('node:https');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const { writeJson } = require('../json-file');
-
-// ZCode 0.16.9 removed inline provider configuration. Its requestAuth override
-// only applies to off-peak account models, not ordinary API-key providers.
-// A private loopback transport keeps the upstream credential in memory; the
-// native provider file contains only a short-lived local capability.
-async function createZCodeProfileRuntime(spec) {
-  const upstream = new URL(spec.provider.baseURL);
-  if (!['http:', 'https:'].includes(upstream.protocol) || upstream.username || upstream.password || upstream.search || upstream.hash) throw new Error('ZCode 模型地址不支持内嵌凭据或查询参数。');
-  const key = spec.provider.apiKey.value;
-  const token = crypto.randomBytes(24).toString('hex');
-  const requests = new Set();
-  const prefix = `/${token}`;
-  const server = http.createServer((req, res) => {
-    const parsed = new URL(req.url, 'http://127.0.0.1');
-    const supplied = req.headers['x-api-key'] || String(req.headers.authorization || '').replace(/^Bearer\s+/i, '');
-    const suffix = parsed.pathname.slice(prefix.length);
-    if (supplied !== token || !parsed.pathname.startsWith(prefix + '/') || req.method !== 'POST' || !['/v1/messages', '/messages', '/chat/completions', '/v1/chat/completions', '/responses', '/v1/responses'].includes(suffix) || parsed.search) { req.resume(); res.writeHead(404); res.end(); return; }
-    const target = new URL(upstream);
-    target.pathname = upstream.pathname.replace(/\/$/, '') + suffix;
-    if (upstream.pathname.endsWith('/v1') && suffix.startsWith('/v1/')) target.pathname = upstream.pathname + suffix.slice(3);
-    const headers = { 'content-type': req.headers['content-type'] || 'application/json' };
-    for (const name of ['anthropic-version', 'anthropic-beta', 'content-length']) if (req.headers[name]) headers[name] = req.headers[name];
-    if (spec.provider.kind === 'anthropic') headers['x-api-key'] = key;
-    else headers.authorization = `Bearer ${key}`;
-    const remote = (target.protocol === 'https:' ? https : http).request(target, { method: 'POST', headers }, incoming => {
-      const allowed = {};
-      for (const name of ['content-type', 'cache-control', 'x-request-id', 'request-id']) if (incoming.headers[name]) allowed[name] = incoming.headers[name];
-      res.writeHead(incoming.statusCode, allowed); res.flushHeaders(); incoming.pipe(res);
-    });
-    requests.add(remote);
-    remote.once('close', () => requests.delete(remote));
-    remote.on('error', () => { if (!res.headersSent) res.writeHead(502, { 'content-type': 'application/json' }); res.end('{"error":{"message":"模型连接失败"}}'); });
-    remote.setTimeout(300000, () => remote.destroy());
-    req.on('aborted', () => remote.destroy());
-    res.on('close', () => { if (!res.writableFinished) remote.destroy(); });
-    let size = 0;
-    req.on('data', bytes => { size += bytes.length; if (size > 8 * 1024 * 1024) { remote.destroy(); req.destroy(); } });
-    req.pipe(remote);
-  });
-  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
-  let root;
-  let file;
-  const selection = { ...spec.model, options: { reasoningLevel: 'enabled' } };
-  try {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'workbench-zcode-runtime-'));
-    file = path.join(root, 'provider-config.json');
-    writeJson(file, { schemaVersion: 1, config: { providerOrder: [selection.providerId], defaultModelSelection: selection, providerConfigRules: { providerRules: [{ providerId: selection.providerId, providerName: 'Workbench', enabled: true, config: { group: 'standard-personal', access: { type: 'api-key', apiKey: token }, api: { type: spec.provider.kind === 'anthropic' ? 'anthropic-messages' : 'openai-chat-completions', baseUrl: `http://127.0.0.1:${server.address().port}${prefix}` }, personalModelIds: [selection.modelId] } }] }, modelConfigRules: { providerModelRules: [], manualProviderModelRules: [] } } });
-  } catch (error) {
-    await new Promise(resolve => server.close(resolve));
-    if (file) { fs.rmSync(file, { force: true }); fs.rmSync(`${file}.${process.pid}.tmp`, { force: true }); }
-    if (root) { try { fs.rmdirSync(root); } catch {} }
-    throw error;
-  }
-  let closed = false;
-  return { selection, file, async close() {
-    if (closed) return; closed = true;
-    for (const request of requests) request.destroy();
-    server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
-    fs.rmSync(file, { force: true });
-    try { fs.rmdirSync(root); } catch { /* never recursively remove native-created files */ }
-  } };
-}
-module.exports = { createZCodeProfileRuntime };
+'use strict';
+const http = require('node:http');
+const https = require('node:https');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { writeJson } = require('../json-file');
+
+// ZCode 0.16.9 removed inline provider configuration. Its requestAuth override
+// only applies to off-peak account models, not ordinary API-key providers.
+// A private loopback transport keeps the upstream credential in memory; the
+// native provider file contains only a short-lived local capability.
+async function createZCodeProfileRuntime(spec) {
+  const upstream = new URL(spec.provider.baseURL);
+  if (!['http:', 'https:'].includes(upstream.protocol) || upstream.username || upstream.password || upstream.search || upstream.hash) throw new Error('ZCode 模型地址不支持内嵌凭据或查询参数。');
+  const key = spec.provider.apiKey.value;
+  const token = crypto.randomBytes(24).toString('hex');
+  const requests = new Set();
+  const prefix = `/${token}`;
+  const server = http.createServer((req, res) => {
+    const parsed = new URL(req.url, 'http://127.0.0.1');
+    const supplied = req.headers['x-api-key'] || String(req.headers.authorization || '').replace(/^Bearer\s+/i, '');
+    const suffix = parsed.pathname.slice(prefix.length);
+    if (supplied !== token || !parsed.pathname.startsWith(prefix + '/') || req.method !== 'POST' || !['/v1/messages', '/messages', '/chat/completions', '/v1/chat/completions', '/responses', '/v1/responses'].includes(suffix) || parsed.search) { req.resume(); res.writeHead(404); res.end(); return; }
+    const target = new URL(upstream);
+    target.pathname = upstream.pathname.replace(/\/$/, '') + suffix;
+    if (upstream.pathname.endsWith('/v1') && suffix.startsWith('/v1/')) target.pathname = upstream.pathname + suffix.slice(3);
+    const headers = { 'content-type': req.headers['content-type'] || 'application/json' };
+    for (const name of ['anthropic-version', 'anthropic-beta', 'content-length']) if (req.headers[name]) headers[name] = req.headers[name];
+    if (spec.provider.kind === 'anthropic') headers['x-api-key'] = key;
+    else headers.authorization = `Bearer ${key}`;
+    const remote = (target.protocol === 'https:' ? https : http).request(target, { method: 'POST', headers }, incoming => {
+      const allowed = {};
+      for (const name of ['content-type', 'cache-control', 'x-request-id', 'request-id']) if (incoming.headers[name]) allowed[name] = incoming.headers[name];
+      res.writeHead(incoming.statusCode, allowed); res.flushHeaders(); incoming.pipe(res);
+    });
+    requests.add(remote);
+    remote.once('close', () => requests.delete(remote));
+    remote.on('error', () => { if (!res.headersSent) res.writeHead(502, { 'content-type': 'application/json' }); res.end('{"error":{"message":"模型连接失败"}}'); });
+    remote.setTimeout(300000, () => remote.destroy());
+    req.on('aborted', () => remote.destroy());
+    res.on('close', () => { if (!res.writableFinished) remote.destroy(); });
+    let size = 0;
+    req.on('data', bytes => { size += bytes.length; if (size > 8 * 1024 * 1024) { remote.destroy(); req.destroy(); } });
+    req.pipe(remote);
+  });
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+  let root;
+  let file;
+  const selection = { ...spec.model, options: { reasoningLevel: 'enabled' } };
+  try {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'workbench-zcode-runtime-'));
+    file = path.join(root, 'provider-config.json');
+    writeJson(file, { schemaVersion: 1, config: { providerOrder: [selection.providerId], defaultModelSelection: selection, providerConfigRules: { providerRules: [{ providerId: selection.providerId, providerName: 'Workbench', enabled: true, config: { group: 'standard-personal', access: { type: 'api-key', apiKey: token }, api: { type: spec.provider.kind === 'anthropic' ? 'anthropic-messages' : 'openai-chat-completions', baseUrl: `http://127.0.0.1:${server.address().port}${prefix}` }, personalModelIds: [selection.modelId] } }] }, modelConfigRules: { providerModelRules: [], manualProviderModelRules: [] } } });
+  } catch (error) {
+    await new Promise(resolve => server.close(resolve));
+    if (file) { fs.rmSync(file, { force: true }); fs.rmSync(`${file}.${process.pid}.tmp`, { force: true }); }
+    if (root) { try { fs.rmdirSync(root); } catch {} }
+    throw error;
+  }
+  let closed = false;
+  return { selection, file, async close() {
+    if (closed) return; closed = true;
+    for (const request of requests) request.destroy();
+    server.closeAllConnections(); await new Promise(resolve => server.close(resolve));
+    fs.rmSync(file, { force: true });
+    try { fs.rmdirSync(root); } catch { /* never recursively remove native-created files */ }
+  } };
+}
+module.exports = { createZCodeProfileRuntime };

package/packages/server/lib/event-stream.js

@@ -1,138 +1,138 @@
-'use strict';
-
-function normalizeEvent(event, sessionId, contextId, sequence, startedAt) {
-  const input = event && typeof event === 'object' ? event : { type: 'claude/error', message: String(event) };
-  const own = Number(input.sequence);
-  return {
-    ...input,
-    type: String(input.type || 'claude/state'),
-    sessionId,
-    contextId,
-    // Publisher-stamped events keep their stable identity; the passed-in
-    // number only positions buffers that were never stamped.
-    sequence: Number.isFinite(own) && own > 0 ? own : sequence,
-    // Real observation time when present; a missing timestamp falls back to
-    // the session start, never a synthetic startedAt+sequence offset.
-    at: input.at || new Date(Date.parse(startedAt || '') || Date.now()).toISOString(),
-  };
-}
-
-// Publish-side identity: every emitted event gets the session's next
-// monotonic sequence and, unless the producer recorded one, the observation
-// time. The counter lives on the session, so tail compaction (dropping the
-// oldest buffered events) never disturbs the numbering.
-function stampEvent(session, event) {
-  const next = (Number(session.eventSequence) || 0) + 1;
-  session.eventSequence = next;
-  event.sequence = next;
-  if (!event.at) event.at = new Date().toISOString();
-  return event;
-}
-
-// Records written before stable identity carry no sequence fields. The
-// retained tail is explicitly renumbered 1..N at restore time and the counter
-// starts at N: the unknown cumulative history is never guessed. Renumbering
-// any event marks a legacy identity transition, which the session carries so
-// subscribeNormalized can distrust pre-transition cursors.
-function resequenceRestoredEvents(events, recordedHighWater) {
-  const list = Array.isArray(events) ? events.filter(item => item && typeof item === 'object') : [];
-  let sequence = 0;
-  let renumbered = 0;
-  const stamped = list.map(event => {
-    const own = Number(event.sequence);
-    if (Number.isFinite(own) && own > 0) {
-      sequence = Math.max(sequence, own);
-      return event;
-    }
-    renumbered += 1;
-    sequence += 1;
-    return { ...event, sequence };
-  });
-  const recorded = Number(recordedHighWater);
-  return {
-    events: stamped,
-    eventSequence: Math.max(sequence, Number.isFinite(recorded) ? recorded : 0),
-    legacyRenumbered: renumbered > 0,
-  };
-}
-
-function subscribeNormalized(runner, sessionId, afterSequence, onEvent) {
-  const state = runner.getState(sessionId);
-  if (!state) throw Object.assign(new Error('session not found'), { status: 404 });
-  const session = typeof runner.getSession === 'function' ? runner.getSession(sessionId) : null;
-  const requested = Number(afterSequence);
-  const after = Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : 0;
-  // Number.isFinite(null) is false, so counters absent on unstamped runners
-  // never masquerade as a zero high-water mark.
-  const highWater = session && Number.isFinite(session.eventSequence)
-    ? session.eventSequence : NaN;
-  const buffer = session && Array.isArray(session.outputBuffer) ? session.outputBuffer : [];
-  let firstRetained = 0;
-  for (const item of buffer) {
-    const own = Number(item && item.sequence);
-    if (Number.isFinite(own) && own > 0) { firstRetained = own; break; }
-  }
-  // Three cursors cannot be served incrementally and must resync explicitly:
-  // one from a numbering era that no longer exists (beyond the high-water
-  // mark: a restart renumbered an unstamped legacy tail, or history was
-  // cleared), one on a session whose retained tail was renumbered from
-  // unstamped legacy records — there ANY non-zero cursor could predate the
-  // transition, including ones at or below the high-water mark, and no
-  // numeric test can prove otherwise — and one the retained tail can no
-  // longer serve continuously (compaction dropped the events between the
-  // cursor and the tail). All open with a sequence-less control marker so
-  // clients reset their dedupe cursor before the full retained replay
-  // instead of silently skipping live events until a fresh local count
-  // catches up.
-  const staleEra = Number.isFinite(highWater) && after > highWater;
-  const legacyTransition = session ? session.legacySequenceReset === true : false;
-  const legacyReset = !staleEra && legacyTransition && after > 0;
-  const historyGap = Number.isFinite(highWater) && after > 0
-    && firstRetained > 0 && (after + 1 < firstRetained
-      // A retained row that carries compaction provenance subsumes every
-      // sequence from compactFrom to its own: a cursor inside that span
-      // already rendered part of the fragment, so serving the merged row as
-      // a delta would duplicate text — the client must resync instead.
-      || buffer.some(item => {
-        const from = Number(item && item.compactFrom);
-        const own = Number(item && item.sequence);
-        return Number.isSafeInteger(from) && from > 0 && Number.isSafeInteger(own) && from <= after && after < own;
-      }));
-  const cursor = staleEra || legacyReset || historyGap ? 0 : after;
-  if (staleEra || legacyReset || historyGap) {
-    onEvent({
-      type: 'workbench/resync',
-      sessionId,
-      contextId: state.projectSlug,
-      at: new Date().toISOString(),
-      reason: staleEra ? 'stale-cursor' : legacyReset ? 'legacy-reset' : 'history-gap',
-      from: after,
-      highWater,
-      firstSequence: firstRetained,
-    });
-  }
-  let legacySequence = 0;
-  return runner.subscribe(sessionId, raw => {
-    const own = Number(raw && raw.sequence);
-    if (Number.isFinite(own) && own > 0) {
-      if (own <= cursor) return;
-      onEvent(normalizeEvent(raw, sessionId, state.projectSlug, own, state.startedAt));
-      return;
-    }
-    // Unstamped runner events (in-memory fakes) keep the historical
-    // per-subscription counting contract.
-    legacySequence += 1;
-    if (legacySequence <= cursor) return;
-    onEvent(normalizeEvent(raw, sessionId, state.projectSlug, legacySequence, state.startedAt));
-  });
-}
-
-function snapshotEvents(runner, sessionId) {
-  const session = runner.getSession(sessionId);
-  const state = runner.getState(sessionId);
-  if (!session || !state) return [];
-  return (session.outputBuffer || []).map((event, index) =>
-    normalizeEvent(event, sessionId, state.projectSlug, index + 1, state.startedAt));
-}
-
-module.exports = { normalizeEvent, subscribeNormalized, snapshotEvents, stampEvent, resequenceRestoredEvents };
+'use strict';
+
+function normalizeEvent(event, sessionId, contextId, sequence, startedAt) {
+  const input = event && typeof event === 'object' ? event : { type: 'claude/error', message: String(event) };
+  const own = Number(input.sequence);
+  return {
+    ...input,
+    type: String(input.type || 'claude/state'),
+    sessionId,
+    contextId,
+    // Publisher-stamped events keep their stable identity; the passed-in
+    // number only positions buffers that were never stamped.
+    sequence: Number.isFinite(own) && own > 0 ? own : sequence,
+    // Real observation time when present; a missing timestamp falls back to
+    // the session start, never a synthetic startedAt+sequence offset.
+    at: input.at || new Date(Date.parse(startedAt || '') || Date.now()).toISOString(),
+  };
+}
+
+// Publish-side identity: every emitted event gets the session's next
+// monotonic sequence and, unless the producer recorded one, the observation
+// time. The counter lives on the session, so tail compaction (dropping the
+// oldest buffered events) never disturbs the numbering.
+function stampEvent(session, event) {
+  const next = (Number(session.eventSequence) || 0) + 1;
+  session.eventSequence = next;
+  event.sequence = next;
+  if (!event.at) event.at = new Date().toISOString();
+  return event;
+}
+
+// Records written before stable identity carry no sequence fields. The
+// retained tail is explicitly renumbered 1..N at restore time and the counter
+// starts at N: the unknown cumulative history is never guessed. Renumbering
+// any event marks a legacy identity transition, which the session carries so
+// subscribeNormalized can distrust pre-transition cursors.
+function resequenceRestoredEvents(events, recordedHighWater) {
+  const list = Array.isArray(events) ? events.filter(item => item && typeof item === 'object') : [];
+  let sequence = 0;
+  let renumbered = 0;
+  const stamped = list.map(event => {
+    const own = Number(event.sequence);
+    if (Number.isFinite(own) && own > 0) {
+      sequence = Math.max(sequence, own);
+      return event;
+    }
+    renumbered += 1;
+    sequence += 1;
+    return { ...event, sequence };
+  });
+  const recorded = Number(recordedHighWater);
+  return {
+    events: stamped,
+    eventSequence: Math.max(sequence, Number.isFinite(recorded) ? recorded : 0),
+    legacyRenumbered: renumbered > 0,
+  };
+}
+
+function subscribeNormalized(runner, sessionId, afterSequence, onEvent) {
+  const state = runner.getState(sessionId);
+  if (!state) throw Object.assign(new Error('session not found'), { status: 404 });
+  const session = typeof runner.getSession === 'function' ? runner.getSession(sessionId) : null;
+  const requested = Number(afterSequence);
+  const after = Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : 0;
+  // Number.isFinite(null) is false, so counters absent on unstamped runners
+  // never masquerade as a zero high-water mark.
+  const highWater = session && Number.isFinite(session.eventSequence)
+    ? session.eventSequence : NaN;
+  const buffer = session && Array.isArray(session.outputBuffer) ? session.outputBuffer : [];
+  let firstRetained = 0;
+  for (const item of buffer) {
+    const own = Number(item && item.sequence);
+    if (Number.isFinite(own) && own > 0) { firstRetained = own; break; }
+  }
+  // Three cursors cannot be served incrementally and must resync explicitly:
+  // one from a numbering era that no longer exists (beyond the high-water
+  // mark: a restart renumbered an unstamped legacy tail, or history was
+  // cleared), one on a session whose retained tail was renumbered from
+  // unstamped legacy records — there ANY non-zero cursor could predate the
+  // transition, including ones at or below the high-water mark, and no
+  // numeric test can prove otherwise — and one the retained tail can no
+  // longer serve continuously (compaction dropped the events between the
+  // cursor and the tail). All open with a sequence-less control marker so
+  // clients reset their dedupe cursor before the full retained replay
+  // instead of silently skipping live events until a fresh local count
+  // catches up.
+  const staleEra = Number.isFinite(highWater) && after > highWater;
+  const legacyTransition = session ? session.legacySequenceReset === true : false;
+  const legacyReset = !staleEra && legacyTransition && after > 0;
+  const historyGap = Number.isFinite(highWater) && after > 0
+    && firstRetained > 0 && (after + 1 < firstRetained
+      // A retained row that carries compaction provenance subsumes every
+      // sequence from compactFrom to its own: a cursor inside that span
+      // already rendered part of the fragment, so serving the merged row as
+      // a delta would duplicate text — the client must resync instead.
+      || buffer.some(item => {
+        const from = Number(item && item.compactFrom);
+        const own = Number(item && item.sequence);
+        return Number.isSafeInteger(from) && from > 0 && Number.isSafeInteger(own) && from <= after && after < own;
+      }));
+  const cursor = staleEra || legacyReset || historyGap ? 0 : after;
+  if (staleEra || legacyReset || historyGap) {
+    onEvent({
+      type: 'workbench/resync',
+      sessionId,
+      contextId: state.projectSlug,
+      at: new Date().toISOString(),
+      reason: staleEra ? 'stale-cursor' : legacyReset ? 'legacy-reset' : 'history-gap',
+      from: after,
+      highWater,
+      firstSequence: firstRetained,
+    });
+  }
+  let legacySequence = 0;
+  return runner.subscribe(sessionId, raw => {
+    const own = Number(raw && raw.sequence);
+    if (Number.isFinite(own) && own > 0) {
+      if (own <= cursor) return;
+      onEvent(normalizeEvent(raw, sessionId, state.projectSlug, own, state.startedAt));
+      return;
+    }
+    // Unstamped runner events (in-memory fakes) keep the historical
+    // per-subscription counting contract.
+    legacySequence += 1;
+    if (legacySequence <= cursor) return;
+    onEvent(normalizeEvent(raw, sessionId, state.projectSlug, legacySequence, state.startedAt));
+  });
+}
+
+function snapshotEvents(runner, sessionId) {
+  const session = runner.getSession(sessionId);
+  const state = runner.getState(sessionId);
+  if (!session || !state) return [];
+  return (session.outputBuffer || []).map((event, index) =>
+    normalizeEvent(event, sessionId, state.projectSlug, index + 1, state.startedAt));
+}
+
+module.exports = { normalizeEvent, subscribeNormalized, snapshotEvents, stampEvent, resequenceRestoredEvents };