token-studio 4.8.0

package/test/annotation-presets.test.mjs

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  applyAnnotationTemplate,
+  QUICK_ANNOTATION_TEMPLATES,
+  readAnnotationPresets,
+  rememberAnnotationPreset,
+  writeAnnotationPresets
+} from '../src/client/dashboard/annotation-presets.js';
+
+function memoryStorage(initial = {}) {
+  const data = new Map(Object.entries(initial));
+  return {
+    getItem(key) {
+      return data.has(key) ? data.get(key) : null;
+    },
+    setItem(key, value) {
+      data.set(key, value);
+    }
+  };
+}
+
+test('rememberAnnotationPreset stores only structured fields and recent projects', () => {
+  const state = rememberAnnotationPreset({}, {
+    projectAlias: 'Token Studio',
+    taskType: '功能开发',
+    outputStatus: '已完成',
+    workPurpose: '功能开发',
+    workStage: '验证',
+    valueLevel: '高',
+    note: 'do not store free text',
+    outputUrl: 'https://example.com/private'
+  });
+
+  assert.deepEqual(state.recentProjects, ['Token Studio']);
+  assert.equal(state.lastTemplate.projectAlias, 'Token Studio');
+  assert.equal(state.lastTemplate.taskType, '功能开发');
+  assert.equal(state.lastTemplate.note, undefined);
+  assert.equal(state.lastTemplate.outputUrl, undefined);
+});
+
+test('rememberAnnotationPreset deduplicates and limits recent projects', () => {
+  let state = {};
+  for (const project of ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'A']) {
+    state = rememberAnnotationPreset(state, { projectAlias: project });
+  }
+
+  assert.deepEqual(state.recentProjects, ['A', 'I', 'H', 'G', 'F', 'E', 'D', 'C']);
+});
+
+test('applyAnnotationTemplate merges template fields without clearing other form data', () => {
+  const form = {
+    projectAlias: '',
+    taskType: '未分类',
+    outputStatus: '未标注',
+    workPurpose: '未说明',
+    workStage: '未说明',
+    valueLevel: '未评估',
+    note: 'keep note',
+    outputUrl: 'https://example.com/output'
+  };
+  const next = applyAnnotationTemplate(form, {
+    projectAlias: 'Token Studio',
+    taskType: '问题修复',
+    outputStatus: '已完成',
+    workPurpose: '调试修复',
+    workStage: '验证',
+    valueLevel: '中'
+  });
+
+  assert.equal(next.projectAlias, 'Token Studio');
+  assert.equal(next.taskType, '问题修复');
+  assert.equal(next.note, 'keep note');
+  assert.equal(next.outputUrl, 'https://example.com/output');
+});
+
+test('quick annotation templates cover common review decisions without free text', () => {
+  assert.deepEqual(QUICK_ANNOTATION_TEMPLATES.map(item => item.id), [
+    'explore-validate',
+    'build-feature',
+    'ship-output',
+    'stop-loss'
+  ]);
+  for (const template of QUICK_ANNOTATION_TEMPLATES) {
+    assert.equal(template.values.note, undefined);
+    assert.equal(template.values.outputUrl, undefined);
+    assert.equal(template.values.outputLabel, undefined);
+  }
+});
+
+test('quick annotation templates can apply without overwriting project or output data', () => {
+  const form = {
+    projectAlias: 'Token Studio',
+    taskType: '未分类',
+    outputStatus: '未标注',
+    workPurpose: '未说明',
+    workStage: '未说明',
+    valueLevel: '未评估',
+    note: 'keep real note',
+    outputUrl: 'https://example.com/pr/1',
+    outputLabel: 'PR #1'
+  };
+  const next = applyAnnotationTemplate(
+    form,
+    QUICK_ANNOTATION_TEMPLATES.find(item => item.id === 'ship-output').values,
+    { includeProjectAlias: false }
+  );
+
+  assert.equal(next.projectAlias, 'Token Studio');
+  assert.equal(next.outputStatus, '已发布');
+  assert.equal(next.workStage, '发布');
+  assert.equal(next.valueLevel, '关键');
+  assert.equal(next.note, 'keep real note');
+  assert.equal(next.outputUrl, 'https://example.com/pr/1');
+  assert.equal(next.outputLabel, 'PR #1');
+});
+
+test('readAnnotationPresets tolerates broken storage data', () => {
+  const storage = memoryStorage({ 'token-studio.annotation-presets.v1': '{bad json' });
+  const state = readAnnotationPresets(storage);
+
+  assert.deepEqual(state.recentProjects, []);
+  assert.equal(state.lastTemplate, null);
+});
+
+test('writeAnnotationPresets round-trips normalized state', () => {
+  const storage = memoryStorage();
+  const state = rememberAnnotationPreset({}, {
+    projectAlias: 'Token Studio',
+    taskType: '功能开发'
+  });
+  writeAnnotationPresets(state, storage);
+
+  const loaded = readAnnotationPresets(storage);
+  assert.deepEqual(loaded.recentProjects, ['Token Studio']);
+  assert.equal(loaded.lastTemplate.taskType, '功能开发');
+});

package/test/api-annotations.test.mjs

@@ -0,0 +1,202 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { openDb, upsertDaily, upsertSession } from '../src/db.mjs';
+
+test('annotation API upserts, merges into /api/data, and deletes', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-api-'));
+  const dbPath = join(dir, 'usage.sqlite');
+  const port = 4300 + Math.floor(Math.random() * 1000);
+  seedDb(dbPath);
+
+  const child = spawn(process.execPath, ['src/server.mjs'], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PORT: String(port),
+      DB_PATH: dbPath,
+      SCHEDULED_COLLECT_ENABLED: 'false'
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+  let stdout = '';
+  let stderr = '';
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data', chunk => { stdout += chunk; });
+  child.stderr.on('data', chunk => { stderr += chunk; });
+
+  try {
+    await waitForApi(port, () => ({ stdout, stderr, exited: child.exitCode != null, exitCode: child.exitCode }));
+    assert.match(stdout, /listening on 127\.0\.0\.1/);
+
+    const initial = await getJson(port, '/api/data');
+    assert.equal(initial.sessions.length, 1);
+    assert.equal(initial.sessions[0].model, 'codex-mini');
+    assert.equal(initial.sessions[0].taskType, '未分类');
+    assert.equal(initial.sessions[0].outputStatus, '未标注');
+    assert.equal(initial.sessions[0].workPurpose, '未说明');
+    assert.equal(initial.sessions[0].workStage, '未说明');
+    assert.equal(initial.sessions[0].valueLevel, '未评估');
+
+    const payload = {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'local:codex:D:\\Project:codex-mini',
+      projectAlias: 'AI 选题雷达',
+      taskType: '功能开发',
+      outputStatus: '已完成',
+      workPurpose: '功能开发',
+      workStage: '实现',
+      valueLevel: '高',
+      note: '完成 v1 标注'
+    };
+
+    await assertRejectsWithStatus(
+      fetch(`http://127.0.0.1:${port}/api/session-annotations`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+        body: JSON.stringify(payload)
+      }),
+      415
+    );
+
+    await assertRejectsWithStatus(
+      fetch(`http://127.0.0.1:${port}/api/session-annotations`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Origin: 'http://evil.example'
+        },
+        body: JSON.stringify(payload)
+      }),
+      403
+    );
+
+    const saved = await postJson(port, '/api/session-annotations', payload);
+    assert.equal(saved.ok, true);
+    assert.equal(saved.annotation.projectAlias, 'AI 选题雷达');
+
+    const annotated = await getJson(port, '/api/data');
+    assert.equal(annotated.meta.taskTypes.includes('功能开发'), true);
+    assert.equal(annotated.sessions[0].projectAlias, 'AI 选题雷达');
+    assert.equal(annotated.sessions[0].taskType, '功能开发');
+    assert.equal(annotated.sessions[0].outputStatus, '已完成');
+    assert.equal(annotated.sessions[0].workPurpose, '功能开发');
+    assert.equal(annotated.sessions[0].workStage, '实现');
+    assert.equal(annotated.sessions[0].valueLevel, '高');
+    assert.equal(annotated.sessions[0].note, '完成 v1 标注');
+
+    const deleted = await deleteJson(port, '/api/session-annotations', {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'local:codex:D:\\Project:codex-mini'
+    });
+    assert.equal(deleted.deleted, 1);
+
+    const cleared = await getJson(port, '/api/data');
+    assert.equal(cleared.sessions[0].projectAlias, null);
+    assert.equal(cleared.sessions[0].taskType, '未分类');
+    assert.equal(cleared.sessions[0].outputStatus, '未标注');
+    assert.equal(cleared.sessions[0].workPurpose, '未说明');
+    assert.equal(cleared.sessions[0].workStage, '未说明');
+    assert.equal(cleared.sessions[0].valueLevel, '未评估');
+  } finally {
+    await stopChild(child);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function seedDb(dbPath) {
+  const db = openDb(dbPath);
+  try {
+    upsertDaily(db, {
+      device: 'devbox',
+      source: 'Codex CLI',
+      usageDate: '2026-06-10',
+      model: 'codex-mini',
+      inputTokens: 100,
+      outputTokens: 30,
+      cacheCreationTokens: 10,
+      cacheReadTokens: 20,
+      reasoningOutputTokens: 5,
+      totalTokens: 165,
+      costUSD: 0.01
+    });
+    upsertSession(db, {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'local:codex:D:\\Project:codex-mini',
+      lastActivity: '2026-06-10T01:00:00.000Z',
+      projectPath: 'D:\\Project',
+      inputTokens: 100,
+      outputTokens: 30,
+      cacheCreationTokens: 10,
+      cacheReadTokens: 20,
+      reasoningOutputTokens: 5,
+      totalTokens: 165,
+      costUSD: 0.01
+    });
+  } finally {
+    db.close();
+  }
+}
+
+async function waitForApi(port, diagnostics) {
+  const start = Date.now();
+  let lastError = null;
+  while (Date.now() - start < 5000) {
+    try {
+      await getJson(port, '/api/data');
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+  const details = diagnostics ? diagnostics() : {};
+  throw new Error(`server did not start in time: ${lastError?.message || 'no response'}\nstdout=${details.stdout || ''}\nstderr=${details.stderr || ''}\nexit=${details.exited ? details.exitCode : 'running'}`);
+}
+
+async function getJson(port, path) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`);
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+async function postJson(port, path, body) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+async function deleteJson(port, path, body) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`, {
+    method: 'DELETE',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+async function assertRejectsWithStatus(responsePromise, expectedStatus) {
+  const response = await responsePromise;
+  assert.equal(response.status, expectedStatus, await response.text());
+}
+
+function stopChild(child) {
+  if (child.exitCode != null) return Promise.resolve();
+  return new Promise(resolve => {
+    child.once('close', resolve);
+    child.kill();
+  });
+}

package/test/api-auto-attribution.test.mjs

@@ -0,0 +1,169 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  openDb,
+  upsertSession,
+  upsertSessionAnnotation
+} from '../src/db.mjs';
+
+test('auto attribution API suggests, applies, protects manual rows, and undoes auto rows', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-api-auto-'));
+  const dbPath = join(dir, 'usage.sqlite');
+  const backupDir = join(dir, 'backups');
+  const port = 6300 + Math.floor(Math.random() * 1000);
+  seedDb(dbPath);
+
+  const child = spawn(process.execPath, ['src/server.mjs'], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PORT: String(port),
+      DB_PATH: dbPath,
+      BACKUP_DIR: backupDir,
+      SCHEDULED_COLLECT_ENABLED: 'false'
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+  let stdout = '';
+  let stderr = '';
+  child.stdout.setEncoding('utf8');
+  child.stderr.setEncoding('utf8');
+  child.stdout.on('data', chunk => { stdout += chunk; });
+  child.stderr.on('data', chunk => { stderr += chunk; });
+
+  try {
+    await waitForApi(port, () => ({ stdout, stderr, exited: child.exitCode != null, exitCode: child.exitCode }));
+
+    const suggestions = await getJson(port, '/api/auto-attribution/suggestions');
+    assert.equal(suggestions.ok, true);
+    assert.equal(suggestions.plan.highConfidenceCount, 1);
+    assert.equal(suggestions.plan.suggestions[0].values.projectAlias, 'TokenStudio');
+
+    await assertRejectsWithStatus(
+      fetch(`http://127.0.0.1:${port}/api/auto-attribution/apply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'text/plain' },
+        body: '{}'
+      }),
+      415
+    );
+
+    const applied = await postJson(port, '/api/auto-attribution/apply', {
+      sessions: suggestions.plan.suggestions.map(row => ({
+        device: row.device,
+        source: row.source,
+        sessionId: row.sessionId
+      }))
+    });
+    assert.equal(applied.applied, 1);
+    assert.equal(existsSync(applied.backup.path), true);
+    assert.ok(applied.runId);
+
+    const data = await getJson(port, '/api/data');
+    const auto = data.sessions.find(session => session.sessionId === 'codex:one');
+    const manual = data.sessions.find(session => session.sessionId === 'claude:two');
+    assert.equal(auto.annotationSource, 'auto');
+    assert.equal(auto.annotationConfidence, 80);
+    assert.equal(auto.attributionQuality, 'auto-high');
+    assert.equal(manual.annotationSource, 'manual');
+    assert.equal(manual.projectAlias, 'Manual Project');
+
+    const undone = await postJson(port, '/api/auto-attribution/undo', { runId: applied.runId });
+    assert.equal(undone.deleted, 1);
+    assert.equal(existsSync(undone.backup.path), true);
+
+    const afterUndo = await getJson(port, '/api/data');
+    assert.equal(afterUndo.sessions.find(session => session.sessionId === 'codex:one').annotationSource, null);
+    assert.equal(afterUndo.sessions.find(session => session.sessionId === 'claude:two').annotationSource, 'manual');
+  } finally {
+    await stopChild(child);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function seedDb(dbPath) {
+  const db = openDb(dbPath);
+  try {
+    upsertSession(db, {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'codex:one',
+      lastActivity: '2026-06-01T01:00:00.000Z',
+      projectPath: 'D:\\HighROIProjects\\TokenStudio',
+      inputTokens: 100,
+      outputTokens: 30,
+      totalTokens: 130,
+      costUSD: 0.01
+    });
+    upsertSession(db, {
+      device: 'devbox',
+      source: 'Claude Code',
+      sessionId: 'claude:two',
+      lastActivity: '2026-06-01T02:00:00.000Z',
+      projectPath: 'D:\\HighROIProjects\\ManualProject',
+      inputTokens: 120,
+      outputTokens: 30,
+      totalTokens: 150,
+      costUSD: 0.02
+    });
+    upsertSessionAnnotation(db, {
+      device: 'devbox',
+      source: 'Claude Code',
+      sessionId: 'claude:two',
+      projectAlias: 'Manual Project',
+      taskType: '功能开发'
+    });
+  } finally {
+    db.close();
+  }
+}
+
+async function waitForApi(port, diagnostics) {
+  const start = Date.now();
+  let lastError = null;
+  while (Date.now() - start < 5000) {
+    try {
+      await getJson(port, '/api/data');
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+  }
+  const details = diagnostics ? diagnostics() : {};
+  throw new Error(`server did not start in time: ${lastError?.message || 'no response'}\nstdout=${details.stdout || ''}\nstderr=${details.stderr || ''}\nexit=${details.exited ? details.exitCode : 'running'}`);
+}
+
+async function getJson(port, path) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`);
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+async function postJson(port, path, body) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+async function assertRejectsWithStatus(responsePromise, expectedStatus) {
+  const response = await responsePromise;
+  assert.equal(response.status, expectedStatus, await response.text());
+}
+
+function stopChild(child) {
+  if (child.exitCode != null) return Promise.resolve();
+  return new Promise(resolve => {
+    child.once('close', resolve);
+    child.kill();
+  });
+}

package/test/api-source-health.test.mjs

@@ -0,0 +1,109 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { openDb, recordRun, upsertSession, upsertTokenEvent } from '../src/db.mjs';
+
+test('source health API returns safe coverage metadata', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'token-studio-source-health-api-'));
+  const dbPath = join(dir, 'usage.sqlite');
+  const port = 6400 + Math.floor(Math.random() * 1000);
+  seedDb(dbPath);
+
+  const child = spawn(process.execPath, ['src/server.mjs'], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      PORT: String(port),
+      DB_PATH: dbPath,
+      SCHEDULED_COLLECT_ENABLED: 'false'
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+
+  try {
+    await waitForApi(port);
+    const health = await getJson(port, '/api/source-health');
+    const codex = health.sources.find(row => row.id === 'codex');
+    assert.equal(codex.health, 'has-data');
+    assert.equal(codex.sessions, 1);
+    assert.equal(codex.readsConversationContent, false);
+
+    const ccusage = health.sources.find(row => row.id === 'ccusage');
+    assert.equal(ccusage.coverageTier, 'ccusage import-bridge');
+    assert.equal(ccusage.tokenEvents, 1);
+    assert.match(ccusage.commandHint, /npx token-studio import-usage/);
+    assert.doesNotMatch(JSON.stringify(health), /C:\\\\Users|prompt|response|transcript|diff/);
+
+    const data = await getJson(port, '/api/data');
+    assert.ok(data.meta.sourceHealth.some(row => row.id === 'codex'));
+  } finally {
+    await stopChild(child);
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function seedDb(dbPath) {
+  const db = openDb(dbPath);
+  try {
+    upsertSession(db, {
+      device: 'devbox',
+      source: 'Codex CLI',
+      sessionId: 'codex-s1',
+      lastActivity: '2026-06-17T02:00:00Z',
+      model: 'gpt-5.3-codex',
+      inputTokens: 100,
+      outputTokens: 20,
+      totalTokens: 120
+    });
+    upsertTokenEvent(db, {
+      eventId: 'ccusage-import-e1',
+      device: 'devbox',
+      source: 'import:ccusage-cli',
+      sessionId: 'import-s1',
+      timestamp: '2026-06-17T03:00:00Z',
+      model: 'claude-sonnet-4-5',
+      inputTokens: 200,
+      outputTokens: 40
+    });
+    recordRun(db, {
+      device: 'devbox',
+      source: 'import:ccusage-cli',
+      status: 'ok',
+      collectedAt: '2026-06-17T03:05:00Z'
+    });
+  } finally {
+    db.close();
+  }
+}
+
+async function waitForApi(port) {
+  const start = Date.now();
+  while (Date.now() - start < 5000) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/api/source-health`);
+      if (response.ok) return;
+    } catch {
+      // Retry while the server starts.
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start in time');
+}
+
+async function getJson(port, path) {
+  const response = await fetch(`http://127.0.0.1:${port}${path}`);
+  if (!response.ok) assert.fail(await response.text());
+  return response.json();
+}
+
+function stopChild(child) {
+  if (child.exitCode != null) return Promise.resolve();
+  return new Promise(resolve => {
+    child.once('close', resolve);
+    child.kill();
+  });
+}