@jjh32456/dsh-longlive 1.6.7 → 1.8.0

package/test/router-1100/wp1-model-status.test.mjs

@@ -1,90 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import test from 'node:test';
-
-import { makeService } from './helpers.mjs';
-
-function auditRecords(file) {
-  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-}
-
-test('model auto with no host resolver stays unresolved and blocks instead of guessing', async () => {
-  const env = makeService({ config: { model: 'auto' } });
-  try {
-    const result = await env.service.start();
-    assert.equal(result.ok, false);
-    assert.equal(result.reason, 'E_NO_PROVIDER');
-    assert.equal(result.state, 'blocked');
-    const status = env.service.status();
-    assert.deepEqual(status.model, { auto: true, resolved: null, resolvedAt: null });
-    assert.equal(status.state, 'blocked');
-    // 只在内存里解析，绝不回写配置，也不把字面量 "auto" 当模型发出去。
-    assert.equal(env.config.model, 'auto');
-    assert.equal(env.service.config.model, 'auto');
-    // 启动在 initPaths 之前就 blocked，不留 audit 目录。
-    assert.equal(status.files.audit, '');
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('the daily window rolls over at local midnight instead of carrying yesterday forever', async () => {
-  let clock = new Date('2026-11-05T10:00:00+08:00');
-  const env = makeService({
-    config: { maxTokensPerDay: 5000, maxTokensPerRun: 50000 },
-    deps: { now: () => clock },
-  });
-  try {
-    const result = await env.service.start();
-    assert.equal(result.state, 'running');
-    // 模拟当天已经用掉 4900，然后时钟跨到第二天。
-    env.service.dayUsage = {
-      day: '2026-11-05',
-      usedTokens: 4900,
-      reservedTokens: 0,
-      capTokens: 5000,
-      runs: [],
-    };
-    clock = new Date('2026-11-06T10:00:00+08:00');
-    await env.service.tick({ tier: 'reflect', reason: 'test' });
-    const status = env.service.status();
-    assert.equal(status.today.day, '2026-11-06');
-    assert.equal(status.today.usedTokens, 0);
-    assert.equal(status.state, 'running');
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('model auto resolves the newest non-preview model into status only', async () => {
-  const env = makeService({ config: { model: 'auto' } });
-  env.llm.listModels = async ({ provider }) => {
-    assert.equal(provider, 'mock');
-    return {
-      models: [
-        { id: 'mock-2-preview' },
-        { id: 'mock-3' },
-        { name: 'mock-4-experimental' },
-      ],
-    };
-  };
-  try {
-    const result = await env.service.start();
-    assert.equal(result.ok, true);
-    assert.equal(result.state, 'running');
-    const status = env.service.status();
-    assert.equal(status.model.auto, true);
-    assert.equal(status.model.resolved, 'mock-3');
-    assert.equal(typeof status.model.resolvedAt, 'string');
-    assert.equal(env.config.model, 'auto');
-    assert.equal(env.service.config.model, 'auto');
-    const start = auditRecords(status.files.audit).filter((record) => record.kind === 'router.start').pop();
-    assert.equal(start.model, 'mock-3');
-    assert.equal(start.model_auto, true);
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});

package/test/router-1100/wp1-status.test.mjs

@@ -1,220 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-
-import {
-  buildStatus,
-  writeStatus,
-  storageErrorCode,
-  STATUS_MAX_BYTES,
-  STATUS_VERSION,
-} from '../../src/router/service/status.mjs';
-
-const NOW = '2026-11-05T00:30:00+08:00';
-
-function withTempDir(fn) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'router-status-'));
-  try {
-    return fn(dir);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-
-test('minimal status is a complete v2 read-only projection', () => {
-  const status = buildStatus({ now: NOW });
-  assert.equal(status.v, STATUS_VERSION);
-  assert.equal(status.v, 2);
-  assert.equal(status.readOnly, true);
-  assert.equal(status.state, 'stopped');
-  assert.equal(status.reason, null);
-  assert.deepEqual(status.provider, { configured: false, missing: true });
-  assert.deepEqual(status.model, { auto: false, resolved: null, resolvedAt: null });
-  assert.equal(status.agentMode, false);
-  assert.deepEqual(status.run, { usedTokens: 0, capTokens: 0 });
-  assert.deepEqual(status.tickQueue, { pending: 0, invalid: 0, oldestAgeMs: 0 });
-  assert.deepEqual(status.queue, { pending: 0, queued: 0, applying: 0, blockedOnUser: 0, expired: 0 });
-  assert.equal(status.board.pulse.unknownSessions, 0);
-  assert.deepEqual(status.live, { rows: 0, maxRows: 128, unknown: 0 });
-  assert.deepEqual(status.warnings, []);
-  assert.deepEqual(status.alerts, []);
-  assert.equal(status.lastError, null);
-  assert.equal(status.lastReport, null);
-  assert.deepEqual(Object.keys(status.files).sort(), ['anchor', 'audit', 'board', 'ledger', 'outbox', 'vault']);
-});
-
-test('provider exposes exactly two booleans and never endpoints or credentials', () => {
-  const status = buildStatus({
-    now: NOW,
-    provider: {
-      configured: true,
-      missing: false,
-      endpoint: 'https://secret.example/v1',
-      apiKey: 'sk-do-not-leak',
-      candidates: ['a', 'b'],
-    },
-  });
-  assert.deepEqual(status.provider, { configured: true, missing: false });
-  assert.equal(JSON.stringify(status).includes('sk-do-not-leak'), false);
-  assert.equal(JSON.stringify(status).includes('secret.example'), false);
-
-  const empty = buildStatus({ now: NOW, provider: 'mock' });
-  assert.deepEqual(empty.provider, { configured: true, missing: false });
-});
-
-test('model reports auto and only the resolved identifier', () => {
-  const auto = buildStatus({ now: NOW, model: { auto: true, resolved: '', resolvedAt: null } });
-  assert.deepEqual(auto.model, { auto: true, resolved: null, resolvedAt: null });
-
-  const resolved = buildStatus({
-    now: NOW,
-    model: { auto: true, resolved: 'deepseek-v4-flash', resolvedAt: NOW, candidates: ['x'] },
-  });
-  assert.deepEqual(Object.keys(resolved.model).sort(), ['auto', 'resolved', 'resolvedAt']);
-  assert.equal(resolved.model.auto, true);
-  assert.equal(resolved.model.resolved, 'deepseek-v4-flash');
-  assert.equal(resolved.model.resolvedAt, NOW);
-
-  const plain = buildStatus({ now: NOW, model: 'mock-1' });
-  assert.deepEqual(plain.model, { auto: false, resolved: 'mock-1', resolvedAt: NOW });
-});
-
-test('tickQueue and the five proposal queue counters are separate', () => {
-  const status = buildStatus({
-    now: NOW,
-    tickQueue: { pending: 2, invalid: 1, oldestAgeMs: 7 },
-    queueStatus: { pending: 1, queued: 2, applying: 3, blockedOnUser: 4, expired: 5 },
-  });
-  assert.deepEqual(status.tickQueue, { pending: 2, invalid: 1, oldestAgeMs: 7 });
-  assert.deepEqual(status.queue, { pending: 1, queued: 2, applying: 3, blockedOnUser: 4, expired: 5 });
-
-  // 兼容 v1 形状的输入：无 tickQueue 时 queue 充当 tickQueue，queue 五键仍独立为零。
-  const legacy = buildStatus({ now: NOW, queue: { pending: 9, invalid: 0, oldestAgeMs: 3 } });
-  assert.deepEqual(legacy.tickQueue, { pending: 9, invalid: 0, oldestAgeMs: 3 });
-  assert.deepEqual(legacy.queue, { pending: 0, queued: 0, applying: 0, blockedOnUser: 0, expired: 0 });
-});
-
-test('warnings are an open enum: known codes get catalog text, unknown codes stay verbatim', () => {
-  const status = buildStatus({
-    now: NOW,
-    warnings: ['BOARD_STALE', 'board_stale', 'ZZ_CUSTOM'],
-  });
-  assert.deepEqual(status.warnings, ['BOARD_STALE', 'ZZ_CUSTOM']);
-  assert.equal(status.alerts.length, 2);
-  assert.equal(status.alerts[0].code, 'BOARD_STALE');
-  assert.equal(status.alerts[0].severity, 'warn');
-  assert.match(status.alerts[0].message, /看板/);
-  assert.equal(status.alerts[1].code, 'ZZ_CUSTOM');
-  assert.match(status.alerts[1].message, /ZZ_CUSTOM/);
-});
-
-test('severity=error alerts are mirrored into warnings, including unknown codes', () => {
-  const status = buildStatus({
-    now: NOW,
-    warnings: ['WAKE_QUOTA'],
-    alerts: [{ code: 'MY_CUSTOM_FATAL', severity: 'error', message: 'boom' }],
-  });
-  assert.ok(status.warnings.includes('MY_CUSTOM_FATAL'));
-  assert.equal(status.alerts[0].code, 'MY_CUSTOM_FATAL');
-  assert.equal(status.alerts[0].severity, 'error');
-});
-
-test('warnings and alerts are capped at eight with errors first', () => {
-  const warnings = Array.from({ length: 12 }, (_, index) => `CUSTOM_${index}`);
-  const alerts = [
-    ...Array.from({ length: 6 }, (_, index) => ({ code: `A_${index}`, severity: 'info', message: 'i' })),
-    ...Array.from({ length: 6 }, (_, index) => ({ code: `E_${index}`, severity: 'error', message: 'e' })),
-  ];
-  const status = buildStatus({ now: NOW, warnings, alerts });
-  assert.equal(status.warnings.length, 8);
-  assert.equal(status.alerts.length, 8);
-  assert.equal(status.alerts[0].severity, 'error');
-  for (const alert of status.alerts.filter((item) => item.severity === 'error')) {
-    assert.ok(status.warnings.includes(alert.code));
-  }
-});
-
-test('focus and blocked entries are bounded and never leak proposal bodies', () => {
-  const focus = Array.from({ length: 12 }, (_, index) => ({
-    sessionId: `s-${index}`,
-    goal: 'g',
-    updatedAt: NOW,
-    content: 'SECRET BODY',
-  }));
-  const blocked = Array.from({ length: 12 }, (_, index) => ({
-    ticket: `t-${index}`,
-    reason: 'r',
-    since: NOW,
-    content: 'SECRET BODY',
-  }));
-  const status = buildStatus({ now: NOW, board: { focus }, proposals: { queue: { blocked } } });
-  assert.equal(status.board.focus.length, 8);
-  assert.deepEqual(Object.keys(status.board.focus[0]).sort(), ['goal', 'lastAction', 'queuedCount', 'sessionId', 'updatedAt']);
-  assert.equal(status.proposals.queue.blocked.length, 8);
-  assert.deepEqual(Object.keys(status.proposals.queue.blocked[0]).sort(), ['reason', 'since', 'ticket']);
-  assert.equal(JSON.stringify(status).includes('SECRET BODY'), false);
-});
-
-test('writeStatus writes v2 atomically, reads it back, and classifies storage errors', () => {
-  withTempDir((dir) => {
-    const file = path.join(dir, 'vault', 'status.json');
-    const result = writeStatus(file, {
-      now: NOW,
-      state: 'running',
-      warnings: ['BOARD_STALE'],
-      lastReport: { summary: 'x'.repeat(2000) },
-    });
-    assert.equal(result.ok, true);
-    assert.ok(result.bytes > 0 && result.bytes <= STATUS_MAX_BYTES);
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    assert.equal(parsed.v, 2);
-    assert.equal(parsed.state, 'running');
-    assert.equal(parsed.lastReport.summary.length, 200);
-    const leftovers = fs.readdirSync(path.join(dir, 'vault')).filter((name) => name.includes('.tmp-'));
-    assert.deepEqual(leftovers, []);
-
-    assert.deepEqual(writeStatus('', {}), { ok: false, error: 'E_STATUS_PATH' });
-  });
-
-  withTempDir((dir) => {
-    const blocker = path.join(dir, 'blocker');
-    fs.writeFileSync(blocker, 'not a directory');
-    const result = writeStatus(path.join(blocker, 'status.json'), { now: NOW });
-    assert.equal(result.ok, false);
-    assert.equal(result.error, 'E_IO');
-  });
-
-  assert.equal(storageErrorCode({ code: 'ENOSPC' }), 'E_STORAGE');
-  assert.equal(storageErrorCode({ code: 'EROFS' }), 'E_STORAGE');
-  assert.equal(storageErrorCode({ code: 'EACCES' }), 'E_STORAGE');
-  assert.equal(storageErrorCode({ code: 'EPERM' }), 'E_STORAGE');
-  assert.equal(storageErrorCode({ code: 'ENOTDIR' }), 'E_IO');
-  assert.equal(storageErrorCode(null), 'E_IO');
-});
-
-test('oversized status shrinks under 16KB without dropping starvation', () => {
-  withTempDir((dir) => {
-    const file = path.join(dir, 'status.json');
-    const alerts = Array.from({ length: 20 }, (_, index) => ({
-      code: `ERR_${index}`,
-      severity: index < 10 ? 'error' : 'info',
-      message: 'm'.repeat(400),
-    }));
-    const result = writeStatus(file, {
-      now: NOW,
-      alerts,
-      warnings: alerts.map((alert) => alert.code),
-      lastError: { code: 'E_BIG', at: NOW, message: 'x'.repeat(5000) },
-      lastReport: { at: NOW, summary: 'y'.repeat(20000) },
-      board: { focus: Array.from({ length: 20 }, (_, i) => ({ sessionId: `s${i}`, goal: 'g', updatedAt: NOW })) },
-      proposals: { queue: { starvation: true, blocked: Array.from({ length: 20 }, () => ({ ticket: 't', reason: 'r', since: NOW })) } },
-    });
-    assert.equal(result.ok, true);
-    assert.ok(result.bytes <= STATUS_MAX_BYTES);
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    assert.equal(parsed.proposals.queue.starvation, true);
-    assert.ok(parsed.alerts.every((alert) => alert.severity === 'error'));
-  });
-});

package/test/router-1100/wp1-tools.test.mjs

@@ -1,146 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createRouterTools } from '../../src/router/service/tools.mjs';
-
-function fakeService(config = { enabled: true }, extra = {}) {
-  const service = {
-    config,
-    runId: 'run-1',
-    panelState: 'running',
-    status: () => ({ v: 2, state: 'running' }),
-    requestTick: () => ({ ok: true }),
-    ask: async () => ({ ok: true }),
-    reportHistory: () => ({ reports: [] }),
-    ...extra,
-  };
-  return service;
-}
-
-function names(tools) {
-  return tools.map((tool) => tool.name);
-}
-
-test('closed surface has four tools; proposal surface adds exactly three', () => {
-  assert.equal(createRouterTools(fakeService()).length, 4);
-  assert.deepEqual(names(createRouterTools(fakeService())), [
-    'router_status',
-    'router_tick',
-    'router_ask',
-    'router_report',
-  ]);
-
-  for (const config of [
-    { enabled: true, proposalEnabled: true },
-    { enabled: true, routerProposalEnabled: true },
-    { enabled: true, routerProposalsEnabled: true },
-  ]) {
-    const tools = createRouterTools(fakeService(config));
-    assert.equal(tools.length, 7);
-    assert.deepEqual(names(tools), [
-      'router_status',
-      'router_tick',
-      'router_ask',
-      'router_report',
-      'router_propose',
-      'router_proposals',
-      'router_apply',
-    ]);
-  }
-
-  // 未开启时不得出现任何未定义工具，字符串 "true" 也不算开启。
-  assert.equal(createRouterTools(fakeService({ enabled: true, proposalEnabled: 'true' })).length, 4);
-  assert.equal(createRouterTools(fakeService({ enabled: true, proposalEnabled: 1 })).length, 4);
-});
-
-test('every router tool has a host-shaped parameter map and a text renderer', () => {
-  const tools = createRouterTools(fakeService({ enabled: true, proposalEnabled: true }));
-  for (const tool of tools) {
-    assert.equal(typeof tool.name, 'string');
-    assert.equal(typeof tool.parameters, 'object');
-    assert.equal(Array.isArray(tool.parameters), false);
-    // Host defineTool expects argument-name -> value schema; a full JSON Schema
-    // object here crashes the host at registration time (UNSUPPORTED_SCHEMA).
-    assert.equal(Object.hasOwn(tool.parameters, 'type'), false);
-    assert.equal(Object.hasOwn(tool.parameters, 'properties'), false);
-    assert.equal(tool.output.schema.type, 'object');
-    const rendered = tool.output.render({}, { ok: true, message: 'hello' });
-    assert.deepEqual(rendered, [{ type: 'text', text: 'hello' }]);
-  }
-});
-
-test('proposal schemas match DESIGN §9.4 within the host value-schema DSL', () => {
-  const tools = createRouterTools(fakeService({ enabled: true, proposalEnabled: true }));
-  const byName = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
-
-  const propose = byName.router_propose.parameters;
-  for (const required of ['op', 'target', 'title', 'content']) {
-    assert.equal(propose[required].required, true);
-  }
-  assert.equal(propose.op.type, 'string');
-  assert.equal(propose.target.type, 'string');
-  assert.equal(propose.title.type, 'string');
-  assert.equal(propose.content.type, 'string');
-  assert.equal(propose.rationale.type, 'string');
-  assert.deepEqual(propose.priority.enum, ['P0', 'P1', 'P2', 'P3', 'P4']);
-  // Length caps live in service validation, not in the host schema DSL.
-  assert.equal(Object.hasOwn(propose.op, 'maxLength'), false);
-
-  const proposals = byName.router_proposals.parameters;
-  assert.deepEqual(proposals.mode.enum, ['list', 'queue', 'detail']);
-  assert.equal(proposals.limit.type, 'integer');
-
-  const apply = byName.router_apply.parameters;
-  assert.equal(apply.mode.required, true);
-  assert.deepEqual(apply.mode.enum, ['approve', 'reject', 'apply', 'rollback', 'cancel']);
-  assert.equal(apply.confirm.type, 'string');
-});
-
-test('router_propose denies P0 before touching the engine, and reports a missing engine honestly', async () => {
-  const tools = createRouterTools(fakeService({ enabled: true, proposalEnabled: true }));
-  const propose = tools.find((tool) => tool.name === 'router_propose');
-  assert.deepEqual(await propose.invoke({ priority: 'P0' }), { ok: false, code: 'E_PRIORITY_DENIED' });
-  assert.equal((await propose.invoke({ op: 'journal.append' })).code, 'E_NOT_IMPLEMENTED');
-
-  const calls = [];
-  const withEngine = createRouterTools(fakeService(
-    { enabled: true, proposalEnabled: true },
-    { proposeProposal: async (args) => { calls.push(args); return { ok: true, ticket: 't-1' }; } },
-  ));
-  const result = await withEngine.find((tool) => tool.name === 'router_propose').invoke({ op: 'journal.append', target: 'x', title: 't', content: 'c' });
-  assert.equal(result.ticket, 't-1');
-  assert.equal(calls.length, 1);
-});
-
-test('router_proposals and router_apply validate before delegating', async () => {
-  const tools = createRouterTools(fakeService({ enabled: true, proposalEnabled: true }));
-  const proposals = tools.find((tool) => tool.name === 'router_proposals');
-  const apply = tools.find((tool) => tool.name === 'router_apply');
-
-  assert.equal((await proposals.invoke({ mode: 'queue' })).code, 'E_NOT_IMPLEMENTED');
-  assert.equal((await apply.invoke({ mode: 'apply' })).code, 'E_APPLY_DISABLED');
-  assert.equal((await apply.invoke({ mode: 'apply', confirm: 'abcdef' })).code, 'E_APPLY_DISABLED');
-  assert.equal((await apply.invoke({ mode: 'approve' })).code, 'E_CONFIRM_REQUIRED');
-  assert.equal((await apply.invoke({ mode: 'rollback' })).code, 'E_APPLY_DISABLED');
-  assert.equal((await apply.invoke({ mode: 'reject' })).code, 'E_NOT_IMPLEMENTED');
-
-  const withEngine = createRouterTools(fakeService(
-    { enabled: true, proposalEnabled: true, applyEnabled: true },
-    {
-      proposalsView: async (args) => ({ ok: true, mode: args.mode }),
-      requestApply: async (args) => ({ ok: true, mode: args.mode, queued: true }),
-    },
-  ));
-  assert.deepEqual(
-    await withEngine.find((tool) => tool.name === 'router_proposals').invoke({ mode: 'queue' }),
-    { ok: true, mode: 'queue' },
-  );
-  assert.deepEqual(
-    await withEngine.find((tool) => tool.name === 'router_apply').invoke({ mode: 'apply', confirm: 'abcdef' }),
-    { ok: true, mode: 'apply', queued: true },
-  );
-  assert.deepEqual(
-    await withEngine.find((tool) => tool.name === 'router_apply').invoke({ mode: 'reject' }),
-    { ok: true, mode: 'reject', queued: true },
-  );
-});