HologramAgent-DSH-Memory-Port/test/loader.test.js

/**
 * Real-loader integration test: mount the plugin the way a dsh profile does.
 *
 * This is the one test that proves the *packaging* is right — `name`/`inject`/
 * `apply` exports, the `defineTool` contract, and `systemPrompt.context` all
 * survive an actual `cordis-plugin-loader` mount rather than a hand-built app.
 *
 * If `cordis-plugin-loader` cannot be resolved (bare install, no dsh), the test
 * skips rather than fails: the plugin itself does not depend on the loader.
 *
 * @module dsh-memory/test/loader
 */

import assert from 'node:assert/strict'
import { mkdtempSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import test from 'node:test'
import { Context } from '@deepseek-ai/cordis'
import { SystemPrompt } from '@deepseek-ai/dsh-system-prompt'
import { ToolRuntime } from '@deepseek-ai/dsh-tools'
import * as plugin from '../lib/index.js'

/** @returns {Promise<unknown>} the loader module, or null when unavailable */
async function tryLoadLoader() {
  try {
    return await import('@deepseek-ai/cordis-plugin-loader')
  } catch {
    return null
  }
}

test('plugin exports the shape the cordis loader requires', () => {
  // A loader entry is only mountable when these three exist.
  assert.equal(typeof plugin.apply, 'function', 'apply(ctx, config) is required')
  assert.equal(typeof plugin.name, 'string', 'name is required for diagnostics')
  assert.ok(Array.isArray(plugin.inject), 'inject must be an array')
  assert.deepEqual(plugin.inject, ['systemPrompt', 'tools'])
  // The default export must be the same plugin (loaders unwrap `default`).
  assert.equal(plugin.default.name, plugin.name)
  assert.equal(plugin.default.apply, plugin.apply)
})

test('mounting twice on the same app fails loudly (service name is taken)', async () => {
  const dir = mkdtempSync(join(tmpdir(), 'dsh-memory-dup-'))
  const ctx = new Context()
  new SystemPrompt(ctx, {})
  new ToolRuntime(ctx, {})
  try {
    plugin.apply(ctx, { path: join(dir, 'a.db') })
    // 'stablemem' is provided by the first instance; cordis refuses a second
    // implementation in the same realm — which is exactly why a preset that
    // wants its own implementation must isolate the service name
    // (docs/shadow-context.md §5.2).
    assert.throws(
      () => plugin.apply(ctx, { path: join(dir, 'b.db') }),
      /stablemem/,
      'duplicate service registration must be rejected',
    )
  } finally {
    await ctx.fiber.dispose()
    rmSync(dir, { recursive: true, force: true })
  }
})

test('an isolated realm can host its own stablemem (the preset route)', async () => {
  const dir = mkdtempSync(join(tmpdir(), 'dsh-memory-iso-'))
  const ctx = new Context()
  new SystemPrompt(ctx, {})
  new ToolRuntime(ctx, {})
  try {
    const outer = plugin.apply(ctx, { path: join(dir, 'outer.db') })
    // A preset subtree isolates the service name and mounts a second instance.
    // Prompt-context names and tool names are NOT partitioned by isolate()
    // (dsh-system-prompt/lib/index.js:204, dsh-tools duplicate check), so a
    // second instance needs a distinct tool name. The prompt-context name is
    // derived from the db path automatically.
    const realm = ctx.isolate('stablemem')
    const inner = plugin.apply(realm, {
      path: join(dir, 'inner.db'),
      toolName: 'stablemem_commit_alt',
      statsToolName: 'stablemem_stats_alt',
    })

    // Both awaits are required: commit() embeds (async) before writing, and
    // relying on "no embedder means it happens synchronously" is exactly the
    // fragile assumption this guards against. Promise.all keeps them concurrent,
    // which is what this test is about (two isolated realms writing in parallel).
    await Promise.all([
      outer.commit({ text: 'outer-only 端口 1111' }),
      inner.commit({ text: 'inner-only 端口 2222' }),
    ])

    assert.equal(outer.store.countBlocks(), 1, 'outer store isolated')
    assert.equal(inner.store.countBlocks(), 1, 'inner store isolated')
    assert.notEqual(outer.store.path, inner.store.path, 'separate databases')

    // The isolated service is reachable through the realm context, and the two
    // contexts resolve DIFFERENT implementations — that is the whole point.
    const realmService = realm.stablemem
    // cordis hands out a PROXY, so identity differs from the instance we built;
    // compare behaviour, not references. (This proxy is also why StableMem keeps
    // ordinary fields instead of #private ones.)
    assert.equal(realmService.store.countBlocks(), 1, 'realm sees only its own block')
    assert.equal(realmService.store.path, inner.store.path, 'realm resolves the inner instance')
    assert.equal(ctx.stablemem.store.path, outer.store.path, 'root resolves the outer instance')
    assert.equal(ctx.stablemem.store.countBlocks(), 1, 'outer store untouched by the realm')
  } finally {
    await ctx.fiber.dispose()
    rmSync(dir, { recursive: true, force: true })
  }
})

test('a real cordis loader can mount the plugin by specifier', async (t) => {
  const loaderModule = await tryLoadLoader()
  if (loaderModule === null) {
    t.skip('cordis-plugin-loader not installed in this environment')
    return
  }
  const dir = mkdtempSync(join(tmpdir(), 'dsh-memory-loader-'))
  const ctx = new Context()
  new SystemPrompt(ctx, {})
  new ToolRuntime(ctx, {})
  try {
    const pluginSpecifier = new URL('../lib/index.js', import.meta.url).href
    const fiber = ctx.plugin(
      {
        name: pluginSpecifier,
        inject: plugin.inject,
        apply: plugin.apply,
      },
      { path: join(dir, 'loaded.db') },
    )
    await fiber.await()
    assert.ok(ctx.stablemem, 'the loaded plugin registered ctx.stablemem')
    assert.ok(
      ctx.tools.schemas().some((schema) => schema.name === 'stablemem_commit'),
      'the loaded plugin registered its tool',
    )
  } finally {
    await ctx.fiber.dispose()
    rmSync(dir, { recursive: true, force: true })
  }
})