@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/integration/install-script.test.mjs

@@ -1,110 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
-const installScript = path.join(root, 'scripts/install.sh');
-
-test('install.sh is a bash npm bootstrap with platform detection', () => {
-  const source = fs.readFileSync(installScript, 'utf8');
-  assert.match(source, /AgentSam installer/);
-  assert.match(source, /npm install --global/);
-  assert.match(source, /Darwin-arm64/);
-  assert.match(source, /--version/);
-  assert.match(source, /--app-id/);
-  assert.match(source, /--app/);
-  assert.doesNotMatch(source, /APP_SELECTOR="\$\{AGENTSAM_DEFAULT_APP/);
-  assert.match(source, /standalone_ready/);
-  assert.match(source, /checksum_contract/);
-});
-
-test('install.sh passes bash syntax validation', () => {
-  const result = spawnSync('bash', ['-n', installScript], { encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-});
-
-test('install.sh maps --app-id and legacy --app aliases to executable launchers', () => {
-  const cases = [
-    ['cad', 'cad-creator', 'agentsam-cad-creator'],
-    ['cms', 'client-cms-editor', 'agentsam-cms'],
-    ['studio', 'local-studio', 'agentsam-studio'],
-    ['database-editor', 'database-editor', 'agentsam-database-editor'],
-  ];
-
-  for (const [alias, appId, executable] of cases) {
-    const temp = fs.mkdtempSync(path.join(os.tmpdir(), `agentsam-install-${alias}-`));
-    const fakeBin = path.join(temp, 'fake-bin');
-    const installRoot = path.join(temp, 'home');
-    const binDir = path.join(temp, 'bin');
-    fs.mkdirSync(fakeBin, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(fakeBin, 'uname'),
-      '#!/usr/bin/env bash\ncase "$1" in -s) echo Darwin ;; -m) echo arm64 ;; esac\n',
-      { mode: 0o755 },
-    );
-    fs.writeFileSync(
-      path.join(fakeBin, 'node'),
-      '#!/usr/bin/env bash\ncase "$*" in *split*) echo 22 ;; *) echo 22.14.0 ;; esac\n',
-      { mode: 0o755 },
-    );
-    fs.writeFileSync(path.join(fakeBin, 'npm'), '#!/usr/bin/env bash\nexit 0\n', { mode: 0o755 });
-    fs.writeFileSync(
-      path.join(fakeBin, 'agentsam'),
-      '#!/usr/bin/env bash\necho "agentsam 2.6.2"\n',
-      { mode: 0o755 },
-    );
-
-    try {
-      const flag = alias === 'database-editor' ? '--app-id' : '--app';
-      const result = spawnSync('bash', [installScript, flag, alias, '--prefix', binDir], {
-        encoding: 'utf8',
-        env: {
-          ...process.env,
-          PATH: `${fakeBin}:${process.env.PATH}`,
-          HOME: temp,
-          AGENTSAM_HOME: installRoot,
-        },
-      });
-      assert.equal(result.status, 0, result.stderr);
-
-      const launcherPath = path.join(binDir, executable);
-      const launcher = fs.readFileSync(launcherPath, 'utf8');
-      assert.match(launcher, new RegExp(`app preview ${appId}`));
-      assert.ok((fs.statSync(launcherPath).mode & 0o111) !== 0);
-
-      const receipt = JSON.parse(fs.readFileSync(path.join(installRoot, 'install-receipt.json'), 'utf8'));
-      assert.equal(receipt.app_id, appId);
-      assert.equal(receipt.app, appId);
-    } finally {
-      fs.rmSync(temp, { recursive: true, force: true });
-    }
-  }
-});
-
-test('install.sh rejects unknown --app-id values before installation', () => {
-  const result = spawnSync('bash', [installScript, '--app-id', 'unknown'], { encoding: 'utf8' });
-  assert.equal(result.status, 2);
-  assert.match(result.stderr, /unknown app/);
-});
-
-test('Local Studio Worker serves installer without AGENTSAM_DEFAULT_APP mutation', () => {
-  const worker = fs.readFileSync(
-    path.join(root, 'apps/local-studio/backend/worker/index.js'),
-    'utf8',
-  );
-  const wrangler = fs.readFileSync(
-    path.join(root, 'apps/local-studio/backend/wrangler.jsonc'),
-    'utf8',
-  );
-
-  assert.match(worker, /import installScript from "\.\.\/\.\.\/\.\.\/\.\.\/scripts\/install\.sh"/);
-  assert.doesNotMatch(worker, /APP_SELECTOR="\\\$\{AGENTSAM_DEFAULT_APP/);
-  assert.match(worker, /text\/x-shellscript/);
-  assert.match(wrangler, /"type": "Text"/);
-  assert.match(wrangler, /"\*\*\/\*\.sh"/);
-});

package/test/integration/inventory-core.test.mjs

@@ -1,53 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  assertModelAvailableForProvider,
-  collectCredentialScopedInventory,
-  filterWorkersAiCurated,
-  makeMapCredentialResolver,
-  sanitizeInventoryForClient,
-} from '../../src/models/inventory-core.js';
-
-test('assertModelAvailableForProvider fails closed on mismatch', () => {
-  assert.throws(
-    () => assertModelAvailableForProvider({ availableModels: [{ provider: 'openai', model_id: 'gpt-x' }] }, 'openai', 'other'),
-    /selected_model_not_available/,
-  );
-  const row = assertModelAvailableForProvider(
-    { availableModels: [{ provider: 'openai', model_id: 'gpt-x', provider_model_id: 'gpt-x' }] },
-    'openai',
-    'gpt-x',
-  );
-  assert.equal(row.model_id, 'gpt-x');
-});
-
-test('vault-scoped inventory sanitizes secrets and discovers only injected providers', async () => {
-  const status = await collectCredentialScopedInventory({
-    credentialPlane: 'studio_vault',
-    resolveCredential: makeMapCredentialResolver(new Map([
-      ['openai', { value: 'sk-secret-should-not-leak', source: 'user_vault' }],
-    ])),
-    fetchImpl: async (url) => {
-      if (String(url).includes('api.openai.com')) {
-        return { ok: true, status: 200, async json() { return { data: [{ id: 'gpt-test' }] }; } };
-      }
-      throw new Error('unexpected ' + url);
-    },
-  });
-  const safe = sanitizeInventoryForClient(status);
-  const text = JSON.stringify(safe);
-  assert.doesNotMatch(text, /sk-secret-should-not-leak/);
-  assert.doesNotMatch(text, /"value"/);
-  assert.equal(safe.credential_plane, 'studio_vault');
-  assert.equal(safe.providers.find((p) => p.id === 'openai')?.source, 'user_vault');
-  assert.deepEqual(safe.availableModels.map((m) => m.model_id), ['gpt-test']);
-  assert.equal(safe.providers.find((p) => p.id === 'gemini')?.configured, false);
-});
-
-test('Workers AI curated filter intersects', () => {
-  const rows = filterWorkersAiCurated([
-    { provider_model_id: '@cf/qwen/qwen2.5-coder-32b-instruct' },
-    { provider_model_id: '@cf/meta/llama-3.2-1b-instruct' },
-  ]);
-  assert.deepEqual(rows.map((r) => r.provider_model_id), ['@cf/qwen/qwen2.5-coder-32b-instruct']);
-});

package/test/integration/inventory-evidence.test.mjs

@@ -1,125 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { buildInventory } from '../../src/indexing/ingest/inventory.js';
-import {
-  extractStyleEvidence,
-  finalizeStyleEvidence,
-  mergeStyleEvidence,
-} from '../../src/indexing/ingest/style-evidence.js';
-import { inventory as knowledgeInventory } from '../../src/knowledge/source.js';
-
-function write(root, rel, text = '') {
-  const abs = path.join(root, rel);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, text);
-}
-
-describe('inventory classifies by evidence', () => {
-  it('uses dominant evidence, root files, tooling LOC, and git ignore state', () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'inv-evidence-'));
-    try {
-      execFileSync('git', ['init', '-q'], { cwd: root });
-      write(root, '.gitignore', '.sites-runtime/\n');
-
-      write(root, 'app/page.tsx', Array.from({ length: 30 }, (_, i) => `export const x${i} = ${i};`).join('\n'));
-      write(root, 'db/schema.sql', 'create table t (id integer);\n');
-      write(root, 'drizzle/meta/_journal.json', '{"version":"1"}\n');
-      for (let i = 1; i <= 9; i += 1) write(root, `plans/p${i}.md`, `# plan ${i}\ntext\n`);
-      write(root, 'plans/schema.sql', 'create table plan (id integer);\n');
-      write(root, 'public/logo.png', 'x');
-      write(root, 'scripts/harvest.py', Array.from({ length: 80 }, (_, i) => `x_${i} = ${i}`).join('\n'));
-      write(root, '.sites-runtime/cache/blob.bin', 'x'.repeat(2048));
-
-      write(root, 'package.json', '{"name":"fixture"}\n');
-      write(root, 'wrangler.jsonc', '{}\n');
-      write(root, 'drizzle.config.ts', 'export default {};\n');
-      write(root, 'README.md', '# Fixture\n');
-      write(root, 'entry.ts', 'export const root = true;\n');
-      write(root, 'package-lock.json', '{"lockfileVersion":3}\n');
-      write(root, '.env', 'SECRET=do-not-index\n');
-      write(root, '.dev.vars', 'TOKEN=do-not-index\n');
-      write(root, 'tls.pem', 'private material\n');
-
-      execFileSync('git', ['add', '.'], { cwd: root });
-
-      const inventory = buildInventory({ root });
-      const categories = inventory.categories;
-
-      assert.ok(categories.source.includes('app'));
-      assert.ok(categories.source.includes('db'));
-      assert.ok(categories.docs.includes('plans'), '9 markdown + 1 SQL is dominantly docs');
-      assert.ok(categories.data.includes('drizzle'), 'JSON-only drizzle metadata is data');
-      assert.ok(categories.assets.includes('public'));
-      assert.ok(categories.operational.includes('.sites-runtime'));
-      assert.ok(categories.tooling.includes('scripts'));
-      assert.deepEqual(categories.unknown, []);
-
-      assert.ok(inventory.suggested.include.includes('scripts'), 'tracked top-2 language tooling is promoted');
-      assert.ok(inventory.top_level_details.scripts.loc >= 80);
-      assert.equal(inventory.top_level_details.scripts.dominant_language, 'Python');
-
-      assert.ok(inventory.root_files.manifest.includes('package.json'));
-      assert.ok(inventory.root_files.manifest.includes('wrangler.jsonc'));
-      assert.ok(inventory.root_files.manifest.includes('drizzle.config.ts'));
-      assert.ok(inventory.root_files.docs.includes('README.md'));
-      assert.ok(inventory.root_files.source.includes('entry.ts'));
-      assert.ok(inventory.root_files.lockfile.includes('package-lock.json'));
-      assert.ok(inventory.root_files.secret.includes('.env'));
-      assert.ok(inventory.root_files.secret.includes('.dev.vars'));
-      assert.ok(inventory.root_files.secret.includes('tls.pem'));
-
-      for (const wanted of ['package.json', 'wrangler.jsonc', 'drizzle.config.ts', 'README.md', 'entry.ts']) {
-        assert.ok(inventory.suggested.include_files.includes(wanted), wanted);
-      }
-      for (const forbidden of ['package-lock.json', '.env', '.dev.vars', 'tls.pem']) {
-        assert.ok(!inventory.suggested.include_files.includes(forbidden), forbidden);
-      }
-
-      const files = knowledgeInventory(root, { include: ['.'], exclude: [] });
-      assert.ok(files.includes('entry.ts'));
-      assert.ok(!files.includes('.env'));
-      assert.ok(!files.includes('.dev.vars'));
-      assert.ok(!files.includes('tls.pem'));
-      assert.ok(!files.includes('package-lock.json'));
-    } finally {
-      fs.rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it('detects coherent theme signatures from markup and CSS evidence', () => {
-    const evidence = extractStyleEvidence(`
-      <html data-theme-preset="fuel-free-time" data-header-preset="adaptive-bar">
-        <link rel="stylesheet" href="/css/heuristic-theme.css">
-        <body>
-          <header class="fnf-header fnf-header--adaptive-bar">
-            <a class="fnf-logo"></a>
-            <nav class="fnf-primary"></nav>
-          </header>
-        </body>
-      </html>
-      <style>
-        :root { --fnf-accent: #ff4d00; --fnf-logo-height: 58px; }
-        .fnf-header { color: var(--fnf-accent); }
-        .fnf-logo { height: var(--fnf-logo-height); }
-      </style>
-    `);
-
-    assert.equal(evidence.theme_presets['fuel-free-time'], 1);
-    assert.equal(evidence.header_presets['adaptive-bar'], 1);
-    assert.equal(evidence.stylesheets['/css/heuristic-theme.css'], 1);
-    const fnf = evidence.namespaces.find((row) => row.prefix === 'fnf');
-    assert.ok(fnf);
-    assert.ok(fnf.signal_kinds >= 2);
-    assert.ok(fnf.signals.class_tokens >= 3);
-    assert.ok(fnf.signals.custom_properties >= 2);
-
-    const final = finalizeStyleEvidence(mergeStyleEvidence(null, evidence));
-    const finalFnf = final.namespaces.find((row) => row.prefix === 'fnf');
-    assert.equal(final.theme_candidate, true);
-    assert.equal(finalFnf?.candidate, true);
-  });
-});

package/test/integration/knowledge-rpc.test.mjs

@@ -1,112 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { defaultConfig } from '../../src/knowledge/config.js';
-import { createKnowledgeJobEngine } from '../../src/knowledge/service/job-engine.js';
-import { startKnowledgeHttpServer } from '../../src/knowledge/service/server.js';
-import { startKnowledgeGrpcServer } from '../../src/knowledge/service/grpc-server.js';
-import { createKnowledgeServiceClient } from '../../src/knowledge/service/client.js';
-import { createKnowledgeGrpcClient } from '../../src/knowledge/service/grpc-client.js';
-import { grpc } from '../../src/knowledge/service/grpc-codec.js';
-
-const fixtureWorker = fileURLToPath(new URL('../fixtures/knowledge-rpc-worker.mjs', import.meta.url));
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
-
-async function waitFor(client, id, wanted = new Set(['completed', 'failed'])) {
-  for (let i = 0; i < 200; i++) {
-    const job = await client.job(id);
-    if (wanted.has(job.status)) return job;
-    await sleep(10);
-  }
-  throw new Error(`Job ${id} did not reach ${[...wanted].join('/')}.`);
-}
-
-async function collect(stream) {
-  const events = [];
-  for await (const event of stream) events.push(event);
-  return events;
-}
-
-test('knowledge HTTP and gRPC adapters share auth, validation, idempotency, lifecycle, cancellation, and durable jobs', async t => {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-rpc-'));
-  t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
-  const root = path.join(tmp, 'repo');
-  const stateDir = path.join(tmp, 'state');
-  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'src', 'sample.js'), 'export const sample = true;\n');
-  const config = defaultConfig({ include: ['src'] });
-  const repositories = { sample: { root, config } };
-  const token = 'r'.repeat(64);
-  const engine = createKnowledgeJobEngine({ stateDir, repositories, workerPath: fixtureWorker, jobTimeoutMs: 2_000 });
-  const http = await startKnowledgeHttpServer({ engine, token, port: 0 });
-  const rpcServer = await startKnowledgeGrpcServer({ engine, token, port: 0 });
-  const httpClient = createKnowledgeServiceClient({ baseUrl: `http://127.0.0.1:${http.address.port}`, token });
-  const rpc = createKnowledgeGrpcClient({ target: rpcServer.target, token });
-  const unauthorized = createKnowledgeGrpcClient({ target: rpcServer.target, token: 'x'.repeat(64) });
-  t.after(async () => {
-    unauthorized.close();
-    rpc.close();
-    await rpcServer.close();
-    await http.close();
-    await engine.close();
-  });
-
-  const repos = await rpc.repositories();
-  assert.deepEqual(repos.repositories, ['sample']);
-  assert.equal(repos.repository_details[0].repository_id, config.repository_id);
-  assert.equal(repos.embeddings_enabled, false);
-  await assert.rejects(unauthorized.repositories(), error => error.status === 401 && error.grpcCode === grpc.status.UNAUTHENTICATED);
-  await assert.rejects(
-    rpc.submit({ repository: 'sample', operation: 'bogus' }),
-    error => error.status === 400 && error.grpcCode === grpc.status.INVALID_ARGUMENT,
-  );
-
-  const request = { repository: 'sample', operation: 'index', generation_id: 'equivalent' };
-  const fromHttp = await httpClient.submit(request, 'cross-transport');
-  const fromGrpc = await rpc.submit(request, 'cross-transport');
-  assert.equal(fromGrpc.id, fromHttp.id);
-  await assert.rejects(
-    rpc.submit({ ...request, scope: 'different' }, 'cross-transport'),
-    error => error.status === 409 && error.grpcCode === grpc.status.ABORTED,
-  );
-  const completed = await waitFor(rpc, fromGrpc.id);
-  assert.equal(completed.status, 'completed');
-  assert.equal((await httpClient.job(fromGrpc.id)).result.repository_id, completed.result.repository_id);
-
-  const blocker = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'blocker');
-  await waitFor(rpc, blocker.id, new Set(['running']));
-  const watched = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'watch' }, 'watched');
-  const lifecycle = await collect(rpc.watch(watched.id));
-  assert.deepEqual(lifecycle.map(event => event.job.status), ['queued', 'running', 'completed']);
-  assert.deepEqual(lifecycle.map(event => event.sequence), [1, 2, 3]);
-
-  const failed = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'fail' }, 'failed');
-  const failureEvents = await collect(rpc.watch(failed.id));
-  assert.equal(failureEvents.at(-1).job.status, 'failed');
-  assert.match(failureEvents.at(-1).job.error, /fixture knowledge failure/);
-
-  const cancellable = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'cancel-watch');
-  const controller = new AbortController();
-  const iterator = rpc.watch(cancellable.id, { signal: controller.signal })[Symbol.asyncIterator]();
-  const first = await iterator.next();
-  assert.equal(first.done, false);
-  controller.abort();
-  const afterAbort = await iterator.next();
-  assert.equal(afterAbort.done, true);
-  assert.equal((await waitFor(rpc, cancellable.id)).status, 'completed');
-
-  const deadlineJob = await rpc.submit({ repository: 'sample', operation: 'index', generation_id: 'slow' }, 'deadline-watch');
-  let deadlineError = null;
-  try {
-    await collect(rpc.watch(deadlineJob.id, { timeoutMs: 15 }));
-  } catch (error) {
-    deadlineError = error;
-  }
-  assert.ok(deadlineError);
-  assert.equal(deadlineError.grpcCode, grpc.status.DEADLINE_EXCEEDED);
-  assert.equal(deadlineError.status, 504);
-  assert.equal((await waitFor(rpc, deadlineJob.id)).status, 'completed');
-});

package/test/integration/local-fs.test.mjs

@@ -1,113 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, it, before, after } from 'node:test';
-import {
-  createLocalFilesystem,
-  createTempWorkspaceRoot,
-  LOCAL_FS_ENGINE,
-} from '../../src/local-fs/index.js';
-import { resolveContainedPath } from '../../src/local-fs/paths.js';
-
-describe('local-fs path containment', () => {
-  /** @type {string} */
-  let root;
-  before(() => {
-    root = createTempWorkspaceRoot();
-    fs.writeFileSync(path.join(root, 'ok.txt'), 'hello\n');
-    fs.mkdirSync(path.join(root, 'sub'));
-  });
-  after(() => {
-    fs.rmSync(root, { recursive: true, force: true });
-  });
-
-  it('resolves relative paths inside root', () => {
-    const r = resolveContainedPath(root, 'ok.txt');
-    assert.equal(r.ok, true);
-    assert.equal(r.rel, 'ok.txt');
-  });
-
-  it('rejects traversal', () => {
-    const r = resolveContainedPath(root, '../outside.txt');
-    assert.equal(r.ok, false);
-    assert.equal(r.code, 'path_escape');
-  });
-
-  it('rejects NUL', () => {
-    const r = resolveContainedPath(root, 'a\0b.txt');
-    assert.equal(r.ok, false);
-    assert.equal(r.code, 'invalid_path');
-  });
-
-  it('rejects symlink escape when possible', () => {
-    const outside = createTempWorkspaceRoot('agentsam-fs-out-');
-    try {
-      fs.writeFileSync(path.join(outside, 'secret.txt'), 'nope');
-      const link = path.join(root, 'escape-link');
-      try {
-        fs.symlinkSync(path.join(outside, 'secret.txt'), link);
-      } catch {
-        // Windows may lack symlink privilege — skip
-        return;
-      }
-      const r = resolveContainedPath(root, 'escape-link');
-      assert.equal(r.ok, false);
-      assert.equal(r.code, 'path_escape');
-    } finally {
-      fs.rmSync(outside, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('local-fs operations', () => {
-  /** @type {string} */
-  let root;
-  /** @type {ReturnType<typeof createLocalFilesystem>} */
-  let fsApi;
-
-  before(() => {
-    root = createTempWorkspaceRoot();
-    fsApi = createLocalFilesystem(root);
-  });
-  after(() => {
-    fs.rmSync(root, { recursive: true, force: true });
-  });
-
-  it('create / read / write with version conflict detection', () => {
-    assert.equal(fsApi.engine, LOCAL_FS_ENGINE);
-    const created = fsApi.create('README.md', '# one\n');
-    assert.equal(created.ok, true);
-    const v1 = created.version;
-
-    const read1 = fsApi.read('README.md');
-    assert.equal(read1.ok, true);
-    assert.equal(read1.content, '# one\n');
-    assert.equal(read1.version, v1);
-
-    const conflict = fsApi.write('README.md', '# stale\n', { expectedVersion: 'sha256:dead' });
-    assert.equal(conflict.ok, false);
-    assert.equal(conflict.code, 'version_conflict');
-
-    const wrote = fsApi.write('README.md', '# two\n', { expectedVersion: v1 });
-    assert.equal(wrote.ok, true);
-    assert.notEqual(wrote.version, v1);
-    assert.equal(fs.readFileSync(path.join(root, 'README.md'), 'utf8'), '# two\n');
-  });
-
-  it('list / rename / remove', () => {
-    fsApi.create('a.txt', 'a');
-    fsApi.mkdir('dir');
-    const listed = fsApi.list('.');
-    assert.equal(listed.ok, true);
-    assert.ok(listed.entries.some((e) => e.path === 'a.txt'));
-
-    const renamed = fsApi.rename('a.txt', 'b.txt');
-    assert.equal(renamed.ok, true);
-    assert.ok(fs.existsSync(path.join(root, 'b.txt')));
-    assert.equal(fs.existsSync(path.join(root, 'a.txt')), false);
-
-    const removed = fsApi.remove('b.txt');
-    assert.equal(removed.ok, true);
-    assert.equal(fs.existsSync(path.join(root, 'b.txt')), false);
-  });
-});

package/test/integration/merkle-cli.test.mjs

@@ -1,61 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const cli = fileURLToPath(new URL('../../src/cli.js', import.meta.url));
-
-async function fixture(t) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'agentsam-merkle-cli-test-'));
-  t.after(() => fs.rm(root, { recursive: true, force: true }));
-  return root;
-}
-
-async function write(root, name, content = name) {
-  await fs.mkdir(path.dirname(path.join(root, name)), { recursive: true });
-  await fs.writeFile(path.join(root, name), content);
-}
-
-function run(args, cwd) {
-  return spawnSync(process.execPath, [cli, 'merkle', ...args], {
-    cwd,
-    encoding: 'utf8',
-    timeout: 15000,
-  });
-}
-
-test('CLI snapshot/verify/diff supports JSON, moved roots, and distinct mismatch/error exit codes', async (t) => {
-  const root = await fixture(t), moved = await fixture(t);
-  await write(root, 'a.txt', 'hello');
-  await write(moved, 'a.txt', 'hello');
-
-  const saved = run(['snapshot', '.', '--json'], root);
-  assert.equal(saved.status, 0, saved.stderr);
-  const manifest = JSON.parse(saved.stdout);
-  assert.ok(manifest.output.endsWith('merkle.json'));
-
-  const matching = run(['verify', manifest.output, '--root', moved, '--json'], root);
-  assert.equal(matching.status, 0, matching.stderr);
-  assert.equal(JSON.parse(matching.stdout).equal, true);
-
-  await write(moved, 'a.txt', 'changed');
-  await write(moved, 'b.txt', 'new');
-  const changed = run(['verify', manifest.output, '--root', moved, '--json'], root);
-  assert.equal(changed.status, 1, changed.stderr);
-  assert.deepEqual(JSON.parse(changed.stdout).stats, { unchanged: 0, modified: 1, added: 1, removed: 0 });
-
-  const diff = run(['diff', root, moved, '--json'], root);
-  assert.equal(diff.status, 1, diff.stderr);
-
-  const invalid = run(['root', '.', '--typo', '--json'], root);
-  assert.equal(invalid.status, 2);
-  assert.equal(invalid.stdout, '');
-  assert.match(JSON.parse(invalid.stderr).error, /Unknown option/);
-
-  const piped = run(['inspect', '.', '--tui'], root);
-  assert.equal(piped.status, 0, piped.stderr);
-  assert.ok(!piped.stdout.includes('\x1b'));
-});

package/test/integration/merkle-persistence-identity.test.mjs

@@ -1,48 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { test } from 'node:test';
-import { resolveMerklePersistenceIdentity } from '../../src/commands/merkle-persist.js';
-
-async function gitFixture(t, remote = null) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'agentsam-merkle-identity-'));
-  t.after(() => fs.rm(root, { recursive: true, force: true }));
-  execFileSync('git', ['init', '-q', root]);
-  if (remote) execFileSync('git', ['-C', root, 'remote', 'add', 'origin', remote]);
-  return root;
-}
-
-test('Merkle persistence identity uses authenticated session + Git provider identity', async (t) => {
-  const root = await gitFixture(t, 'git@github.com:SamPrimeaux/agentsam-sdk.git');
-  const identity = resolveMerklePersistenceIdentity(root, {
-    session: { account_id: 'au_test' },
-    projectConfig: { repository: { id: 'local:should-not-win' } },
-  });
-  assert.deepEqual(identity, {
-    accountId: 'au_test',
-    repositoryId: 'github:samprimeaux/agentsam-sdk',
-    repositoryIdentitySource: 'git',
-  });
-});
-
-test('local repositories fall back to committed project identity', async (t) => {
-  const root = await gitFixture(t);
-  const identity = resolveMerklePersistenceIdentity(root, {
-    session: { account_id: 'au_test' },
-    projectConfig: { repository: { id: 'local:fixture-repository' } },
-  });
-  assert.equal(identity.repositoryId, 'local:fixture-repository');
-  assert.equal(identity.repositoryIdentitySource, 'project_manifest');
-});
-
-test('Merkle persistence refuses unauthenticated ownership', async (t) => {
-  const root = await gitFixture(t, 'https://github.com/SamPrimeaux/agentsam-sdk.git');
-  assert.throws(() => resolveMerklePersistenceIdentity(root, { session: null }), /agentsam_login_required_for_merkle_persistence/);
-});
-
-test('Merkle persistence CLI has no account/repository ownership env shortcuts', async () => {
-  const source = await fs.readFile(new URL('../../src/commands/merkle-persist.js', import.meta.url), 'utf8');
-  assert.doesNotMatch(source, /AGENTSAM_ACCOUNT_ID|AGENTSAM_REPOSITORY_ID|--account-id|--repository-id/);
-});

package/test/integration/plugins-cloudflare.integration.test.mjs

@@ -1,28 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  AGENTSAM_MCP_PLUGIN_MANIFEST,
-  INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST,
-} from '../../src/plugins/index.js';
-
-test('Cloudflare OAuth installations have distinct client and callback contracts', () => {
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.plugin_key, 'agentsam-mcp');
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.auth_type, 'oauth');
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.oauth_connect_url, '/api/connections/cloudflare/start');
-  assert.equal(
-    AGENTSAM_MCP_PLUGIN_MANIFEST.config.callback_url,
-    'https://agentsam.inneranimalmedia.com/api/connections/cloudflare/callback',
-  );
-  assert.equal(AGENTSAM_MCP_PLUGIN_MANIFEST.config.token_auth_method, 'none_pkce');
-
-  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.plugin_key, 'inneranimalmedia-cf-oauth');
-  assert.equal(INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.auth_type, 'oauth_via_iam');
-  assert.equal(
-    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.oauth_connect_url,
-    'https://inneranimalmedia.com/api/oauth/cloudflare/start',
-  );
-  assert.equal(
-    INNERANIMALMEDIA_CLOUDFLARE_OAUTH_PLUGIN_MANIFEST.config.callback_url,
-    'https://inneranimalmedia.com/api/oauth/cloudflare/callback',
-  );
-});