dsh-molbio-tools 0.22.0 → 0.22.2

package/test/contract.mjs

@@ -102,6 +102,70 @@ function hostHalf(pkg) {
   return existsSync(path) ? { path, text: readFileSync(path, 'utf8') } : undefined;
 }
 
+/**
+ * The declaration evidence for a contract check, from whichever copy this
+ * installation carries.
+ *
+ * The npm packages ship `lib/types/*.d.ts`; the DESKTOP build (app.asar)
+ * strips them to save space (`dsh-fs` ships no `lib/types` at all and
+ * `dsh-llm` keeps only the declarations `lib/typert.host.js` embeds for its
+ * type registry). The contract is the same in both builds, so a desktop
+ * verification must not report the packaging difference as a contract change.
+ * The fallbacks therefore read the same declarations where the build kept them;
+ * `\n`/`\"` escapes in the embedded copy are unescaped so one regex serves
+ * both.
+ *
+ * This is still a guard: when NO candidate exists the check fails loudly
+ * instead of skipping, and `the declaration guard still fails when a
+ * declaration moves` below drives the same assertions with mutated text.
+ *
+ * @param pkg the `@deepseek-ai/*` package name.
+ * @param candidates package-relative paths, in preference order.
+ * @returns the first existing file's text and path.
+ */
+function declarationEvidence(pkg, candidates) {
+  const dir = packageDir(pkg);
+  for (const relative of candidates) {
+    const path = join(dir, relative);
+    if (!existsSync(path)) continue;
+    const text = readFileSync(path, 'utf8').replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\'/g, "'");
+    return { text, path };
+  }
+  assert.fail(`${pkg} ships none of ${candidates.join(', ')} — the declaration guard cannot read its evidence`);
+}
+
+/** The ImageBlock half of the picture contract, over a declaration text. */
+function assertImageBlockDeclared(types) {
+  const imageBlock = /interface ImageBlock \{[\s\S]*?\n\}/.exec(types)?.[0] ?? '';
+  assert.match(imageBlock, /type: 'image'/, 'ImageBlock still declares type "image"');
+  assert.match(imageBlock, /attachment: ImageAttachmentRef/, 'and still carries a durable attachment reference');
+}
+
+/** The ImageAttachmentRef fields our output value mirrors. */
+function assertImageRefDeclared(types) {
+  const ref = /interface ImageAttachmentRef \{[\s\S]*?\n\}/.exec(types)?.[0] ?? '';
+  for (const field of ['attachmentId', 'mediaType', 'bytes', 'width', 'height']) {
+    assert.ok(ref.includes(`${field}:`), `ImageAttachmentRef still carries ${field}`);
+  }
+}
+
+/**
+ * The store method the picture hand-off calls: the TypeScript declaration on a
+ * build that ships types, or the runtime method that implements it on the
+ * desktop build, which strips `lib/types`.
+ */
+function assertSaveImageDeclared(indexTypes) {
+  const declared = /saveImage\(input: SaveImageAttachment\): Promise<ImageAttachmentRef>/.test(indexTypes);
+  const implemented = /async saveImage\(input\)/.test(indexTypes);
+  assert.ok(declared || implemented, 'the store still exposes saveImage');
+}
+
+/** The text-only filesystem seam the picture workaround rests on. */
+function assertFsSeamDeclared(fsText, fsIndexText) {
+  assert.ok(fsText.includes('FS_NOT_TEXT'), 'the filesystem seam still carries FS_NOT_TEXT');
+  assert.ok(!/\bwriteBytes\b/.test(fsIndexText), 'no binary write primitive appeared on the fs seam');
+}
+
 /** Every file under a directory, bounded (the shell bundle ships under dist/). */
 function filesUnder(dir, limit = 400) {
   const out = [];
@@ -277,6 +341,24 @@ check('the built bundle registers the seats and services the framework expects',
   // The inject factory must hand over exactly the services the framework does
   // NOT provide, so it can never shadow sessionId or a synthesised hook.
   assert.ok(/inject: \(\) => \(\{ remote \}\)/.test(bundle), 'the body injects only the Remote face');
+
+  // The plugin-detail key section depends on TWO upstream facts: the plugin
+  // manager still declares the seat, and the settings controller still exposes
+  // the credentials Remote namespace with the argument order we call. Both are
+  // silent if they move (the section simply never renders), so pin them here.
+  assert.ok(bundle.includes('plugins.detail.section'), 'the bundle waits for the plugin-manager detail seat');
+  for (const call of ['credentials.describe(', 'credentials.set(', 'credentials.unset(']) {
+    assert.ok(bundle.includes(call), `the key section calls ${call}…)`);
+  }
+  assert.ok(bundle.includes("ctx.inject(['remote.credentials']"), 'the key section declares the credentials FIBER INJECTION (a plain property is undefined)');
+  const manager = clientBundle('@deepseek-ai/dsh-client-ui-plugin-manager');
+  assert.ok(manager !== undefined && manager.text.includes('plugins.detail.section'), 'the plugin manager still declares plugins.detail.section');
+  const settings = hostHalf('@deepseek-ai/dsh-api-settings-controller');
+  assert.ok(settings !== undefined, 'the settings controller is installed');
+  assert.ok(settings.text.includes('namespace: "credentials"'), 'the credentials Remote namespace still exists');
+  assert.match(settings.text, /async describe\(refs\)/, 'describe takes the reference list first');
+  assert.match(settings.text, /async set\(ref, value\)/, 'set takes (ref, value)');
+  assert.match(settings.text, /async unset\(ref\)/, 'unset takes the reference');
 });
 
 check('the package manifest keeps the client declaration the scan keys on', () => {
@@ -460,10 +542,12 @@ check('every seat claim waits for the declaration (slots.inject, not a bare regi
 
   // Our artifact: every `register` must sit inside a wait for that same seat.
   const bundle = readFileSync(join(packageRoot, 'lib', 'client.js'), 'utf8');
-  const waited = [...bundle.matchAll(/slots\.inject\('([^']+)', \(\) => (?:ctx\.)?slots\.register\(\{\s*name: '([^']+)'/g)];
+  // The receiver may be a fiber context (`keyCtx.slots`), not only `ctx.slots`:
+  // the key section registers inside a ctx.inject gate.
+  const waited = [...bundle.matchAll(/slots\.inject\('([^']+)', \(\) => (?:[A-Za-z_$][\w$]*\.)?slots\.register\(\{\s*name: '([^']+)'/g)];
   assert.ok(waited.length > 0, 'the bundle claims its seats through slots.inject');
   for (const [, seat, name] of waited) assert.equal(seat, name, `the claim of ${name} waits for the seat it registers into`);
-  const registers = (bundle.match(/(?:ctx\.)?slots\.register\(/g) ?? []).length;
+  const registers = (bundle.match(/(?:[A-Za-z_$][\w$]*\.)?slots\.register\(/g) ?? []).length;
   assert.equal(registers, waited.length, 'and no registration exists outside such a wait');
 });
 
@@ -607,20 +691,13 @@ check('a tool may show the model a picture the way read_image does', () => {
   // Our output.render builds `{ type: 'image', attachment: {...} }`; that shape
   // must stay the harness's own ImageBlock, and the reference fields must stay
   // the ones our output value mirrors.
-  const llmTypes = readFileSync(join(packageDir('@deepseek-ai/dsh-llm'), 'lib', 'types', 'types.d.ts'), 'utf8');
-  const imageBlock = /interface ImageBlock \{[\s\S]*?\n\}/.exec(llmTypes)?.[0] ?? '';
-  assert.match(imageBlock, /type: 'image'/, 'ImageBlock still declares type "image"');
-  assert.match(imageBlock, /attachment: ImageAttachmentRef/, 'and still carries a durable attachment reference');
-
-  const attachmentTypes = readFileSync(join(packageDir('@deepseek-ai/dsh-attachment'), 'lib', 'types', 'types.d.ts'), 'utf8');
-  const ref = /interface ImageAttachmentRef \{[\s\S]*?\n\}/.exec(attachmentTypes)?.[0] ?? '';
-  for (const field of ['attachmentId', 'mediaType', 'bytes', 'width', 'height']) {
-    assert.ok(ref.includes(`${field}:`), `ImageAttachmentRef still carries ${field}`);
-  }
+  assertImageBlockDeclared(declarationEvidence('@deepseek-ai/dsh-llm', ['lib/types/types.d.ts', 'lib/typert.host.js']).text);
+  // The desktop build strips dsh-attachment's own `lib/types`, so the durable
+  // reference is read from the copy `dsh-llm/lib/typert.host.js` embeds.
+  assertImageRefDeclared(declarationEvidence('@deepseek-ai/dsh-attachment', ['lib/types/types.d.ts', 'lib/types/index.d.ts', '../dsh-llm/lib/typert.host.js']).text);
 
   // The commit call, and that this deployment accepts what we encode.
-  const attachmentIndex = readFileSync(join(packageDir('@deepseek-ai/dsh-attachment'), 'lib', 'types', 'index.d.ts'), 'utf8');
-  assert.match(attachmentIndex, /saveImage\(input: SaveImageAttachment\): Promise<ImageAttachmentRef>/, 'the store still exposes saveImage');
+  assertSaveImageDeclared(declarationEvidence('@deepseek-ai/dsh-attachment', ['lib/types/index.d.ts', '../dsh-attachment-local/lib/index.js']).text);
   const attachmentLocal = readFileSync(join(packageDir('@deepseek-ai/dsh-attachment-local'), 'lib', 'index.js'), 'utf8');
   assert.ok(attachmentLocal.includes('"image/png"'), 'this deployment still accepts image/png');
 
@@ -643,12 +720,57 @@ check('the workspace still cannot hold a binary file (the reason the picture rid
   // the filesystem seam is text-only. If DSH grows a binary write, this check
   // fails on purpose: revisit the design (png_path becomes possible) rather
   // than silently keeping the workaround.
-  const fsTypes = readFileSync(join(packageDir('@deepseek-ai/dsh-fs'), 'lib', 'types', 'types.d.ts'), 'utf8');
-  assert.ok(fsTypes.includes('FS_NOT_TEXT'), 'the filesystem seam still types FS_NOT_TEXT');
+  // `dsh-fs`'s own base class carries no code list; the refusal code lives in
+  // the local backend (the base is consulted last, only as a presence fallback).
+  const fsTypes = declarationEvidence('@deepseek-ai/dsh-fs', ['lib/types/types.d.ts', '../dsh-fs-local/lib/index.js', 'lib/index.js']).text;
   const fsReadme = readFileSync(join(packageDir('@deepseek-ai/dsh-fs'), 'README.md'), 'utf8');
   assert.match(fsReadme, /binary-safe mutations remain deferred/i, 'and still documents binary mutations as deferred');
   const fsIndex = readFileSync(join(packageDir('@deepseek-ai/dsh-fs'), 'lib', 'index.js'), 'utf8');
-  assert.ok(!/\bwriteBytes\b/.test(fsIndex), 'no binary write primitive appeared on the fs seam');
+  assertFsSeamDeclared(fsTypes, fsIndex);
+});
+
+check('the declaration guard still fails when a declaration moves (the build fallback is not vacuous)', () => {
+  // 0.22.2 taught the two checks above to read the declarations a DESKTOP build
+  // embeds instead of the `lib/types` it strips. A fallback that cannot fail
+  // would turn those checks into decoration, so drive every predicate with a
+  // mutated copy of the SAME evidence the installation supplied: each one must
+  // reject the mutation. (rules.md rule 9.)
+  const llm = declarationEvidence('@deepseek-ai/dsh-llm', ['lib/types/types.d.ts', 'lib/typert.host.js']).text;
+  const attachment = declarationEvidence('@deepseek-ai/dsh-attachment', ['lib/types/types.d.ts', 'lib/types/index.d.ts', '../dsh-llm/lib/typert.host.js']).text;
+  const attachmentIndex = declarationEvidence('@deepseek-ai/dsh-attachment', ['lib/types/index.d.ts', '../dsh-attachment-local/lib/index.js']).text;
+  const fsText = declarationEvidence('@deepseek-ai/dsh-fs', ['lib/types/types.d.ts', '../dsh-fs-local/lib/index.js', 'lib/index.js']).text;
+
+  const imageBlock = /interface ImageBlock \{[\s\S]*?\n\}/.exec(llm)?.[0] ?? '';
+  assert.notEqual(imageBlock, '', 'the mutation experiment found a real ImageBlock declaration to mutate');
+  assert.throws(
+    () => assertImageBlockDeclared(llm.replace(imageBlock, imageBlock.replace("type: 'image'", "type: 'picture'"))),
+    'a moved ImageBlock type is caught',
+  );
+  assert.throws(
+    () => assertImageBlockDeclared(llm.replace(imageBlock, imageBlock.replace('ImageAttachmentRef', 'SomeOtherRef'))),
+    'a moved attachment reference is caught',
+  );
+
+  const refBlock = /interface ImageAttachmentRef \{[\s\S]*?\n\}/.exec(attachment)?.[0] ?? '';
+  assert.notEqual(refBlock, '', 'the mutation experiment found a real ImageAttachmentRef declaration to mutate');
+  assert.throws(
+    () => assertImageRefDeclared(attachment.replace(refBlock, refBlock.replace('attachmentId:', 'id:'))),
+    'a renamed attachment field is caught',
+  );
+
+  assert.throws(
+    () => assertSaveImageDeclared(attachmentIndex.split('saveImage(').join('putImage(')),
+    'a renamed saveImage is caught',
+  );
+
+  assert.throws(
+    () => assertFsSeamDeclared(fsText.split('FS_NOT_TEXT').join('FS_BINARY_REFUSED'), ''),
+    'a renamed FS error code is caught',
+  );
+  assert.throws(
+    () => assertFsSeamDeclared(fsText, 'function writeBytes() {}'),
+    'a binary write primitive is caught',
+  );
 });
 
 check('the harness decodes the PNG our rasterizer produces (and refuses a corrupt one)', async () => {

package/test/map-card.mjs

@@ -253,12 +253,14 @@ function mount(Component) {
 const registrations = [];
 const module = await import(entryPath.href);
 const slots = createSlotsStub(['sidebar.right.pane.tab', 'sidebar.right.pane.tab.title', 'tool.call.toolview']);
-module.apply({
+const cardCtx = {
   remote: {},
   effect: (factory) => factory(),
+  inject: (_deps, callback) => ({ dispose() {}, value: callback(cardCtx) }),
   sidebarRightTabs: { register: (definition) => registrations.push(definition) },
   slots,
-});
+};
+module.apply(cardCtx);
 const MapCard = slots.registrations.find(
   (entry) => entry.registration.name === 'tool.call.toolview' && entry.registration.key === 'molbio_plasmid_map',
 ).component;

package/test/panel-render.mjs

@@ -308,12 +308,17 @@ const module = await (async () => {
   }
 })();
 
-const slots = createSlotsStub(['sidebar.right.pane.tab', 'sidebar.right.pane.tab.title', 'tool.call.toolview']);
+const slots = createSlotsStub(['sidebar.right.pane.tab', 'sidebar.right.pane.tab.title', 'tool.call.toolview', 'plugins.detail.section']);
 const ctx = {
   remote: remote({}),
   effect(factory) {
     return factory();
   },
+  // `apply` gates the key section on the credentials Remote namespace; this
+  // file supplies every dependency it asks for, like the default composition.
+  inject(_deps, callback) {
+    return { dispose() {}, value: callback(ctx) };
+  },
   sidebarRightTabs: { register: (definition) => registrations.push(definition) },
   slots,
 };
@@ -594,6 +599,77 @@ const library = {
   harness.unmount();
 }
 
+// ── the plugin-detail key section (write-only credential form) ─────────────
+
+{
+  const claim = slots.registrations.find((entry) => entry.registration.name === 'plugins.detail.section');
+  assert.ok(claim, 'the key section registered once its seat was declared');
+  const store = { value: undefined, describe: [], set: [], unset: [], refuse: '' };
+  ctx.remote.credentials = {
+    async describe(refs) {
+      store.describe.push(refs);
+      return {
+        ok: true,
+        value: {
+          NCBI_API_KEY: {
+            configured: store.value !== undefined,
+            writable: true,
+            ...store.value === undefined ? {} : { source: 'file' },
+          },
+        },
+      };
+    },
+    async set(ref, value) {
+      store.set.push([ref, value]);
+      if (store.refuse !== '') return { ok: false, error: { message: store.refuse } };
+      store.value = value;
+      return { ok: true, value: null };
+    },
+    async unset(ref) {
+      store.unset.push(ref);
+      store.value = undefined;
+      return { ok: true, value: null };
+    },
+  };
+  const subject = { kind: 'bundle', pkg: { name: 'dsh-molbio-tools' } };
+  const wrapper = claim.component({ subject });
+  const harness = mount(wrapper.type);
+  globalThis.__molbioTestHooks = harness;
+  harness.setProps({ subject, remote: ctx.remote });
+  await harness.render();
+  assert.deepEqual(store.describe[0], ['NCBI_API_KEY'], 'the section asks only about its own reference');
+  assert.match(markup(harness.tree), /Not configured/, 'an empty store reads as not configured');
+  const input = elements(harness.tree, 'input')[0];
+  assert.equal(input.props.type, 'password', 'the key is typed into a password field');
+  input.props.onChange({ target: { value: '  key-123  ' } });
+  await harness.render();
+  const save = elements(harness.tree, 'button').find((node) => texts(node).join('') === 'Save');
+  await save.props.onClick();
+  await flush();
+  await harness.render();
+  assert.deepEqual(store.set, [['NCBI_API_KEY', 'key-123']], 'Save trims and stores under NCBI_API_KEY');
+  assert.ok(store.describe.length >= 2, 'the status is re-read after the write');
+  assert.match(markup(harness.tree), /Configured \(source: file\)/, 'the status names the source, never the value');
+  assert.equal(elements(harness.tree, 'input')[0].props.value, '', 'the draft is cleared after saving');
+
+  const remove = elements(harness.tree, 'button').find((node) => texts(node).join('') === 'Remove');
+  await remove.props.onClick();
+  await flush();
+  await harness.render();
+  assert.deepEqual(store.unset, ['NCBI_API_KEY'], 'Remove deletes the reference');
+  assert.match(markup(harness.tree), /Not configured/, 'the status follows the removal');
+
+  // A provider refusal is shown verbatim instead of being swallowed.
+  store.refuse = 'credential/rejected: the credentials file is unreadable';
+  elements(harness.tree, 'input')[0].props.onChange({ target: { value: 'x' } });
+  await harness.render();
+  await elements(harness.tree, 'button').find((node) => texts(node).join('') === 'Save').props.onClick();
+  await flush();
+  await harness.render();
+  assert.ok(markup(harness.tree).includes('credential/rejected: the credentials file is unreadable'), 'a refused write keeps the host message');
+  harness.unmount();
+}
+
 // ── effects are disposed on unmount ─────────────────────────────────────────
 
 {

package/test/smoke.mjs

@@ -1989,6 +1989,55 @@ delete process.env.MOLBIO_NCBI_API_KEY;
   }
 }
 
+{
+  // the harness credential store outranks the environment without ever
+  // materializing the key in process.env; an explicit argument still wins.
+  const saved = process.env.NCBI_API_KEY;
+  process.env.NCBI_API_KEY = 'env-loses';
+  extraServices.set('credentials', {
+    async resolve(ref) {
+      return ref === 'NCBI_API_KEY' ? { value: 'store-key', source: 'store' } : undefined;
+    },
+  });
+  try {
+    mockWeb.calls.length = 0;
+    const stored = await run('molbio_pubmed_search', { query: 'stored key' });
+    assert.equal(stored.backend, 'pubmed-eutils');
+    assert.ok(mockWeb.calls.length === 2 && mockWeb.calls.every((url) => url.includes('api_key=store-key')));
+
+    mockWeb.calls.length = 0;
+    const explicit = await run('molbio_pubmed_search', { query: 'explicit key', api_key: 'arg-key' });
+    assert.equal(explicit.backend, 'pubmed-eutils');
+    assert.ok(mockWeb.calls.every((url) => url.includes('api_key=arg-key')));
+  } finally {
+    extraServices.delete('credentials');
+    delete process.env.NCBI_API_KEY;
+    if (saved !== undefined) process.env.NCBI_API_KEY = saved;
+  }
+}
+
+{
+  // a credential provider that refuses the ref must degrade to the environment,
+  // not break the tool (a composition may have no store at all).
+  const saved = process.env.NCBI_API_KEY;
+  process.env.NCBI_API_KEY = 'env-fallback';
+  extraServices.set('credentials', {
+    async resolve() {
+      throw new Error('no credential store in this composition');
+    },
+  });
+  try {
+    mockWeb.calls.length = 0;
+    const out = await run('molbio_pubmed_search', { query: 'fallback' });
+    assert.equal(out.backend, 'pubmed-eutils');
+    assert.ok(mockWeb.calls.length === 2 && mockWeb.calls.every((url) => url.includes('api_key=env-fallback')));
+  } finally {
+    extraServices.delete('credentials');
+    delete process.env.NCBI_API_KEY;
+    if (saved !== undefined) process.env.NCBI_API_KEY = saved;
+  }
+}
+
 {
   // an invalid key is reported as such, not presented as "no results"
   await assert.rejects(() => run('molbio_pubmed_search', { query: 'x', api_key: 'bad-key' }), /API key invalid/);