dsh-better-display 0.3.7 → 0.3.8

package/tests/retiring-content.test.ts

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { runInNewContext } from 'node:vm';
+import ts from 'typescript';
+
+const source = readFileSync(new URL('../src/client/motion.tsx', import.meta.url), 'utf8');
+const retiring = source.slice(source.indexOf('export function RetiringContent('), source.indexOf('// DOM-only behavior:'));
+const compiled = ts.transpileModule(`const EASING = 'cubic-bezier(.22,1,.36,1)';\n${retiring}`, {
+  fileName: 'retiring.tsx',
+  compilerOptions: { module: ts.ModuleKind.CommonJS, jsx: ts.JsxEmit.ReactJSX },
+}).outputText;
+
+// Drive the component's real effect with deterministic hooks and a compositor
+// that never finishes unless the test explicitly sends onfinish.
+function mount() {
+  let cursor = 0;
+  let enabled = true;
+  const hooks: unknown[] = [];
+  const effects = new Map<number, { deps: unknown[]; cleanup?: () => void }>();
+  let pending: Array<{ index: number; run: () => (() => void) | void; deps: unknown[] }> = [];
+  let timerId = 0;
+  const timers = new Map<number, { run: () => void; duration: number }>();
+  const animations: Array<{ onfinish?: () => void; cancelled: number }> = [];
+  const element = {
+    contains: () => false,
+    getBoundingClientRect: () => ({ height: 64 }),
+    animate: (_frames: unknown, options: { duration: number; fill: string }) => {
+      assert.equal(options.duration, 220);
+      assert.equal(options.fill, 'both');
+      const animation = { cancelled: 0, cancel() { this.cancelled++; } };
+      animations.push(animation);
+      return animation;
+    },
+  };
+  const effect = (run: () => (() => void) | void, deps: unknown[]) => {
+    const index = cursor++;
+    const previous = effects.get(index);
+    if (!previous || deps.some((value, at) => value !== previous.deps[at])) pending.push({ index, run, deps });
+  };
+  const exports: { RetiringContent?: (props: { visible: boolean; children: string }) => unknown } = {};
+  runInNewContext(compiled, {
+    exports,
+    require: createRequire(import.meta.url),
+    css: { retiringContent: 'retiring' },
+    StreamMotionContext: {},
+    document: { activeElement: null },
+    window: {
+      setTimeout: (run: () => void, duration: number) => { timers.set(++timerId, { run, duration }); return timerId; },
+      clearTimeout: (id: number) => { timers.delete(id); },
+    },
+    useContext: () => ({ enabled }),
+    useRef: (initial: unknown) => {
+      const index = cursor++;
+      if (!(index in hooks)) hooks[index] = { current: initial };
+      return hooks[index];
+    },
+    useState: (initial: unknown) => {
+      const index = cursor++;
+      if (!(index in hooks)) hooks[index] = initial;
+      return [hooks[index], (value: unknown) => { hooks[index] = value; }];
+    },
+    useLayoutEffect: effect,
+    useEffect: effect,
+  });
+  assert.equal(typeof exports.RetiringContent, 'function');
+  const render = (visible: boolean) => {
+    cursor = 0;
+    pending = [];
+    const result = exports.RetiringContent!({ visible, children: 'narration' }) as { ref: { current: unknown } } | null;
+    if (result) result.ref.current = element;
+    for (const { index, run, deps } of pending) {
+      effects.get(index)?.cleanup?.();
+      effects.set(index, { deps, cleanup: run() ?? undefined });
+    }
+    return result;
+  };
+  render(true);
+  return {
+    render, timers, animations,
+    disableMotion: () => { enabled = false; },
+    unmount: () => { for (const effect of effects.values()) effect.cleanup?.(); },
+    deadline: () => {
+      const [id, timer] = [...timers][0] ?? [];
+      assert.ok(timer, 'retiring animation must have a deadline');
+      assert.equal(timer.duration, 460);
+      timers.delete(id);
+      timer.run();
+    },
+  };
+}
+
+test('retiring narration unmounts on its deadline when onfinish never fires', () => {
+  const view = mount();
+  assert.ok(view.render(false));
+  view.deadline();
+  assert.equal(view.animations[0].cancelled, 1);
+  assert.equal(view.render(false), null);
+  view.unmount();
+});
+
+test('normal finish settles once and removes the deadline on cleanup', () => {
+  const view = mount();
+  view.render(false);
+  view.animations[0].onfinish?.();
+  view.animations[0].onfinish?.();
+  assert.equal(view.animations[0].cancelled, 1);
+  assert.equal(view.render(false), null);
+  view.unmount();
+  assert.equal(view.timers.size, 0);
+});
+
+test('visibility reversal and unmount cancel the deadline and release animation fill', () => {
+  const view = mount();
+  view.render(false);
+  const staleFinish = view.animations[0].onfinish;
+  assert.ok(view.render(true));
+  assert.equal(view.timers.size, 0);
+  assert.equal(view.animations[0].cancelled, 1);
+  staleFinish?.();
+  assert.ok(view.render(true));
+  view.render(false);
+  view.unmount();
+  assert.equal(view.timers.size, 0);
+  assert.equal(view.animations[1].cancelled, 1);
+});
+
+test('disabled motion retires immediately without an animation or timer', () => {
+  const view = mount();
+  view.disableMotion();
+  view.render(false);
+  assert.equal(view.render(false), null);
+  assert.equal(view.animations.length, 0);
+  assert.equal(view.timers.size, 0);
+  view.unmount();
+});

package/tests/reveal.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Context } from '@deepseek-ai/cordis';
+import { createRevealHandler, resolveRevealPath, revealPath, revealRoots } from '../src/reveal.js';
+import { isAbsoluteWorkspacePath } from '../src/workspace-path.js';
+import { dirname } from '../src/client/deliverables.js';
+
+test('absolute parent predicate accepts POSIX, drive and UNC roots only', () => {
+  for (const path of ['/', '/repo', 'C:\\', 'C:/', 'D:\\5- AI\\docs', '\\\\server\\share']) {
+    assert.equal(isAbsoluteWorkspacePath(path), true, path);
+  }
+  for (const path of ['', '.', 'docs', './docs', '../docs', 'C:', 'C:docs', '\\docs']) {
+    assert.equal(isAbsoluteWorkspacePath(path), false, path);
+  }
+  assert.equal(dirname('/a.txt'), '/');
+  assert.equal(dirname('C:\\a.txt'), 'C:\\');
+  assert.equal(dirname('C:/a.txt'), 'C:/');
+  assert.equal(isAbsoluteWorkspacePath(dirname('docs/a.txt')), false);
+});
+
+async function workspace(t: { after: (cleanup: () => Promise<void>) => void }) {
+  const root = await mkdtemp(join(tmpdir(), 'bd-reveal-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  await mkdir(join(root, 'docs'));
+  await writeFile(join(root, 'docs', 'report.md'), 'report');
+  return root;
+}
+
+test('relative resolution uses an existing full path, rejects missing and ambiguous matches', async t => {
+  const root = await workspace(t);
+  const other = await workspace(t);
+  assert.equal(resolveRevealPath('docs/report.md', [root]), join(root, 'docs', 'report.md'));
+  assert.equal(resolveRevealPath('docs/report.md', ['/missing-root', root, root]), join(root, 'docs', 'report.md'));
+  assert.throws(() => resolveRevealPath('docs/missing.md', [root]), /not found/);
+  assert.throws(() => resolveRevealPath('docs/report.md', []), /not found/);
+  assert.throws(() => resolveRevealPath('docs/report.md', [root, other]), /ambiguous/);
+  assert.equal(resolveRevealPath('/absolute/file', []), '/absolute/file');
+});
+
+test('relative resolution preserves Windows drive and UNC spelling', () => {
+  const exists = (path: string) => ['D:\\5- AI\\docs\\report.md', '\\\\server\\share\\docs\\report.md'].includes(path);
+  assert.equal(resolveRevealPath('docs/report.md', ['D:\\5- AI'], exists), 'D:\\5- AI\\docs\\report.md');
+  assert.equal(resolveRevealPath('docs/report.md', ['\\\\server\\share'], exists), '\\\\server\\share\\docs\\report.md');
+  assert.throws(() => resolveRevealPath('C:report.md', ['D:\\5- AI'], exists), /not workspace-relative/);
+  assert.throws(() => resolveRevealPath('\\report.md', ['D:\\5- AI'], exists), /not workspace-relative/);
+});
+
+function context(services: Record<string, unknown>): Context {
+  return { get: (name: string) => services[name] } as unknown as Context;
+}
+
+test('host roots use only the target live session or its registered workspace', async () => {
+  const ctx = context({
+    sessions: { get: (id: string) => id === 'target' ? { header: { cwd: '/target' } } : undefined },
+    workspaceRegistry: { list: () => [
+      { path: '/other', sessionIds: ['other'] },
+      { path: '/cold', sessionIds: ['cold'] },
+    ] },
+  });
+  assert.deepEqual(await revealRoots(ctx, 'target'), ['/target']);
+  assert.deepEqual(await revealRoots(ctx, 'cold'), ['/cold']);
+  assert.deepEqual(await revealRoots(ctx, 'unknown'), []);
+  assert.deepEqual(await revealRoots(ctx, undefined), ['/other', '/cold']);
+});
+
+test('cold session roots are read without projections and the observation is disposed', async () => {
+  let disposed = false;
+  const ctx = context({ sessionQuery: {
+    observeSession: async (id: string, options: unknown) => {
+      assert.equal(id, 'cold');
+      assert.deepEqual(options, { projectionMode: 'none' });
+      return { header: { cwd: '/cold' }, [Symbol.dispose]: () => { disposed = true; } };
+    },
+  } });
+  assert.deepEqual(await revealRoots(ctx, 'cold'), ['/cold']);
+  assert.equal(disposed, true);
+});
+
+async function request(handler: ReturnType<typeof createRevealHandler>, body: string, method = 'POST') {
+  const req = new IncomingMessage(new Socket());
+  req.method = method;
+  const res = new ServerResponse(req);
+  const response = new Promise<{ status: number; body: string }>(resolve => {
+    res.end = (chunk: string) => {
+      resolve({ status: res.statusCode, body: chunk ?? '' });
+      return res;
+    };
+  });
+  handler(req, res);
+  req.emit('data', body);
+  req.emit('end');
+  return response;
+}
+
+test('reveal route resolves a session-relative request and never opens a missing path', async t => {
+  const root = await workspace(t);
+  const opened: string[] = [];
+  const handler = createRevealHandler({
+    roots: async sessionId => { assert.equal(sessionId, 'target'); return [root]; },
+    reveal: path => { opened.push(path); },
+  });
+  assert.deepEqual(await request(handler, JSON.stringify({ path: 'docs/report.md', sessionId: 'target' })), {
+    status: 200, body: '{"ok":true}',
+  });
+  assert.equal((await request(handler, JSON.stringify({ path: 'docs/missing.md', sessionId: 'target' }))).status, 400);
+  assert.deepEqual(opened, [join(root, 'docs', 'report.md')]);
+  assert.equal((await request(handler, '{}')).status, 400);
+  assert.equal((await request(handler, 'invalid')).status, 400);
+  assert.equal((await request(handler, '', 'GET')).status, 405);
+});
+
+test('absolute requests bypass root lookup and Explorer receives a quoted verbatim selection', async () => {
+  const path = 'D:\\5- AI\\docs\\report.md';
+  const calls: unknown[] = [];
+  const handler = createRevealHandler({
+    roots: async () => { throw new Error('absolute requests do not need roots'); },
+    reveal: target => revealPath(target, 'win32', (...args) => { calls.push(args); }),
+  });
+  assert.equal((await request(handler, JSON.stringify({ path }))).status, 200);
+  assert.deepEqual(calls, [['explorer.exe', ['/select,"D:\\5- AI\\docs\\report.md"'], {
+    detached: true, stdio: 'ignore', windowsVerbatimArguments: true,
+  }]]);
+});

package/tests/stock-install.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { test } from 'node:test';
@@ -63,6 +64,13 @@ test('commits compiled lib entries and does not require a prepare script', () =>
   assert.doesNotMatch(clientJs, /submission\.images\.length/);
 });
 
+test('compiled host entry loads in Node without a TypeScript loader', () => {
+  const result = spawnSync(process.execPath, ['--input-type=module', '--eval',
+    "const plugin = await import('./lib/dsh-better-display.js'); if (plugin.name !== 'dsh-better-display' || typeof plugin.apply !== 'function') process.exit(1);",
+  ], { cwd: root, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr || String(result.error ?? 'host entry did not load'));
+});
+
 test('README leads with the official stock one-liner and names pnpm', () => {
   for (const name of ['README.md', 'README.en.md']) {
     const text = readFileSync(resolve(root, name), 'utf8');

package/tests/styles.test.ts

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { ensureStyles } from '../src/client/styles.js';
+
+test('ensureStyles tolerates module evaluation without a document', () => {
+  ensureStyles();
+});
+
+test('ensureStyles restores removed plugin CSS and remains idempotent', t => {
+  const descriptor = Object.getOwnPropertyDescriptor(globalThis, 'document');
+  t.after(() => {
+    if (descriptor) Object.defineProperty(globalThis, 'document', descriptor);
+    else Reflect.deleteProperty(globalThis, 'document');
+  });
+  const reader = { dataset: { plugin: 'dsh-better-display', pluginCss: 'dsh-better-display/Reader.module.css' }, textContent: '.reader{height:auto}' };
+  const fold = { dataset: { plugin: 'dsh-better-display', pluginCss: 'dsh-better-display/Fold.module.css' }, textContent: '.fold{overflow:hidden}' };
+  const foreign = { dataset: { plugin: 'other', pluginCss: 'other/Fold.module.css' }, textContent: '.other{}' };
+  const tags = [reader, fold, foreign];
+  const document = {
+    querySelectorAll: (selector: string) => {
+      assert.equal(selector, 'style[data-plugin="dsh-better-display"][data-plugin-css]');
+      return tags.filter(tag => tag.dataset.plugin === 'dsh-better-display');
+    },
+    createElement: (name: string) => { assert.equal(name, 'style'); return { dataset: {}, textContent: '' }; },
+    head: { appendChild: (tag: typeof reader) => { tags.push(tag); } },
+  };
+  Object.defineProperty(globalThis, 'document', { configurable: true, value: document });
+  ensureStyles();
+  assert.equal(tags.length, 3);
+  tags.splice(0, 2);
+  ensureStyles();
+  assert.deepEqual(tags, [foreign, reader, fold]);
+  ensureStyles();
+  assert.equal(tags.length, 3);
+  tags[1].textContent = '.reader{height:100px}';
+  ensureStyles();
+  tags.splice(1, 1);
+  ensureStyles();
+  assert.equal(tags.find(tag => tag.dataset.pluginCss === reader.dataset.pluginCss)?.textContent, '.reader{height:100px}');
+});
+
+test('CSS is cached after module injection and restored before mount layout effects', () => {
+  const index = readFileSync(new URL('../src/client/index.tsx', import.meta.url), 'utf8');
+  const reader = readFileSync(new URL('../src/client/Reader.tsx', import.meta.url), 'utf8');
+  assert.match(index, /\nensureStyles\(\);/);
+  assert.match(reader, /useInsertionEffect\(\(\) => \{ ensureStyles\(\); \}, \[\]\)/);
+});

package/tests/terminal-input-preview.test.ts

@@ -0,0 +1,113 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import type { PreparingToolCall, RunningToolCall, ToolResultNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import { activityPhase, activitySummary } from '../src/client/tool-activity.ts';
+import type { ToolDraft } from '../src/client/tool-activity.ts';
+
+function draft(name: string, argsRaw: string): ToolDraft {
+  return { kind: 'tool-call', callId: 'terminal-preview', name, argsRaw };
+}
+
+test('terminal drafts expose a pending placeholder state until a command field appears', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const early = activitySummary({ draft: draft(name, '{"comman') });
+    assert.equal(early.category, 'terminal');
+    assert.equal(early.argsState, 'partial');
+    assert.equal(early.command, undefined);
+
+    const partial = activitySummary({ draft: draft(name, '{"command":"Get-C') });
+    assert.equal(partial.argsState, 'partial');
+    assert.equal(partial.command, 'Get-C');
+  }
+});
+
+test('complete Bash and PowerShell arguments remain available in full', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const values = {
+      command: name === 'pwsh' ? 'Get-ChildItem -Force' : 'printf "ready\\n"',
+      workdir: '/work/project',
+      description: 'List project files',
+      timeout_ms: 4000,
+    };
+    const model = activitySummary({ draft: draft(name, JSON.stringify(values)) });
+    assert.equal(model.argsState, 'complete');
+    assert.equal(model.command, values.command);
+    assert.deepEqual(model.args, values);
+  }
+});
+
+test('partial escaped and multiline commands keep their authored text', () => {
+  const argsRaw = '{"command":"printf \\"first\\nsecond';
+  const model = activitySummary({ draft: draft('bash', argsRaw) });
+  assert.equal(model.argsState, 'partial');
+  assert.equal(model.command, 'printf "first\nsecond');
+
+  const multiline = 'printf "first line\\nsecond line"\necho 你好';
+  const complete = activitySummary({ draft: draft('bash', JSON.stringify({ command: multiline, workdir: '/tmp' })) });
+  assert.equal(complete.command, multiline);
+  assert.equal(complete.args.workdir, '/tmp');
+});
+
+test('complete empty and non-command arguments are not mistaken for partial commands', () => {
+  const empty = activitySummary({ draft: draft('bash', '{}') });
+  assert.equal(empty.argsState, 'complete');
+  assert.deepEqual(empty.args, {});
+  assert.equal(empty.command, undefined);
+
+  const read = activitySummary({ draft: draft('read', '{"path":"/tmp/readme.md"}') });
+  assert.equal(read.argsState, 'complete');
+  assert.equal(read.category, 'read');
+  assert.equal(read.command, undefined);
+  assert.equal(read.args.path, '/tmp/readme.md');
+});
+
+test('the activity lifecycle distinguishes draft, dispatched call, and result', () => {
+  const argsRaw = '{"command":"echo ready"}';
+  const pending = draft('bash', argsRaw);
+  const running: RunningToolCall = {
+    phase: 'start', callId: pending.callId, name: pending.name, turn: 1, step: 0, time: 1000, argsRaw, subCalls: [],
+  };
+  const result: ToolResultNode = {
+    kind: 'tool-result', seq: 2, time: 2000, callId: pending.callId,
+    call: { name: pending.name, argsRaw }, callTime: 1000,
+    content: [{ type: 'text', text: 'ready\n[exit code: 0]' }], isError: false, meta: { exitCode: 0 }, subCalls: [],
+  };
+  assert.equal(activityPhase({ draft: pending }), 'preparing');
+  assert.equal(activityPhase({ block: running }), 'running');
+  assert.equal(activityPhase({ block: result }), 'succeeded');
+});
+
+test('a canonical preparing call remains preparing until dispatch', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const block: PreparingToolCall = {
+      phase: 'preparing', callId: 'preparing-head', name, turn: 1, step: 0, time: 1000, subCalls: [],
+    };
+    assert.equal(activityPhase({ block }), 'preparing');
+    assert.equal(activityPhase({ block }, true), 'interrupted');
+    const model = activitySummary({ block });
+    assert.equal(model.name, name);
+    assert.equal(model.argsState, 'partial');
+    assert.equal(model.raw, '');
+    assert.equal(model.command, undefined);
+  }
+});
+
+test('a canonical preparing head retains progressively generated draft arguments', () => {
+  for (const name of ['bash', 'pwsh']) {
+    const block: PreparingToolCall = {
+      phase: 'preparing', callId: 'preparing-head', name, turn: 1, step: 0, time: 1000, subCalls: [],
+    };
+    for (const raw of ['{"comman', '{"command":"echo ready']) {
+      const pending = { ...draft(name, raw), callId: block.callId };
+      const model = activitySummary({ block, draft: pending });
+      assert.equal(model.raw, raw);
+      assert.equal(model.argsState, 'partial');
+      assert.equal(model.command, raw === '{"comman' ? undefined : 'echo ready');
+    }
+    const dispatched: RunningToolCall = { ...block, phase: 'start', argsRaw: '{"command":"echo sent"}' };
+    const model = activitySummary({ block: dispatched, draft: draft(name, '{"command":"stale') });
+    assert.equal(activityPhase({ block: dispatched }), 'running');
+    assert.equal(model.command, 'echo sent');
+    assert.equal(model.argsState, 'complete');
+  }
+});

package/tsdown.config.ts

@@ -40,12 +40,60 @@ const portableOutput: TsdownPlugin = {
   },
 };
 
+/**
+ * Guard against the 0.3.7 regression class: the host entry must not ship a
+ * relative specifier that cannot resolve inside the published tarball.
+ *
+ * The specific failure was `import ... from "./skill-roots.ts"` — a path to the
+ * TypeScript source that is never emitted next to the entry, so the host died
+ * with ERR_MODULE_NOT_FOUND on every start while the market still reported the
+ * plugin as installed. A build-time assertion turns that silent publish-time
+ * mistake into a red build.
+ */
+const hostPortableOutput: TsdownPlugin = {
+  name: 'dsh-better-display-host-portable-output',
+  generateBundle(_options, output) {
+    for (const [fileName, chunk] of Object.entries(output)) {
+      if (chunk.type !== 'chunk') continue;
+      const offenders = [
+        // Relative specifiers that still point at TS sources.
+        ...chunk.code.matchAll(/from\s*["'](\.[^"']*\.ts)["']/g),
+        // Relative specifiers reaching into node_modules-written shapes.
+        ...chunk.code.matchAll(/from\s*["'](\.\.?\/[^"']*node_modules\/[^"']*)["']/g),
+      ].map((match) => match[1]);
+      if (offenders.length > 0) {
+        this.error(
+          `${fileName} contains relative specifiers that will not resolve in the published package: ` +
+            `${[...new Set(offenders)].join(', ')}. Relative imports must be bundled, not externalised ` +
+            `(see the neverBundle note above).`,
+        );
+      }
+    }
+  },
+};
+
 export default bundle.map((config) => {
   if (config.name === 'dsh-better-display') {
     const { external: _external, ...hostConfig } = config;
     return {
       ...hostConfig,
-      deps: { ...hostConfig.deps, neverBundle: (specifier: string) => !specifier.startsWith('.') },
+      plugins: [
+        ...(Array.isArray(hostConfig.plugins)
+          ? hostConfig.plugins
+          : hostConfig.plugins === undefined
+            ? []
+            : [hostConfig.plugins]),
+        hostPortableOutput,
+      ],
+      // NEVER re-introduce a resolved-id predicate here. tsdown may hand this
+      // callback an already-resolved absolute path, in which case a
+      // `!specifier.startsWith('.')` test is true for EVERY module and the
+      // relative source imports get externalised instead of bundled — the
+      // host entry then ships as `import ... from "./skill-roots.ts"`, which
+      // no longer exists in the package (0.3.7 regression, ERR_MODULE_NOT_FOUND).
+      // `true` keeps the documented semantics: bare npm specifiers stay
+      // external "as written", relative imports keep being bundled.
+      deps: { ...hostConfig.deps, neverBundle: true },
     };
   }
   if (config.name !== 'dsh-better-display/client') return config;