@north-light/crouter 0.3.318 → 0.3.319

package/dist/daemon/api/__tests__/seam/api-server.test.js

@@ -1,442 +0,0 @@
-// Run with: node --import tsx/esm --test src/daemon/api/__tests__/seam/api-server.test.ts
-//
-// A-11 — the Stage-A acceptance gate for the crtrd API server (spec §10, plan
-// §Stage A). Proves A1–A8: the `CrtrClient` HTTP+WS transport drives the FULL
-// server → router → handlers → bridge stack over the real unix socket, against a
-// CRTR_HOME-isolated crtrd, with a fake broker engine (zero LLM cost).
-//
-// COMPILED SEAM (real-boot-bound): this file lives in `__tests__/seam/`, so
-// `npm run test:seam` runs it from emitted JavaScript with the other real broker
-// and tmux journeys. It is tmux-free (createHeadlessHarness) but boots REAL
-// broker processes, so it is outside the ordinary local loop.
-//
-// APPROACH (see this node's a11-plan.md): the harness stands in for crtrd
-// (in-process superviseTick, fake-live-daemon pidfile, isolated CRTR_HOME + the
-// fake-pi/fake-engine seams); we additionally start `createApiServer()`
-// IN-PROCESS, which binds the unix socket at `apiSocketPath()` == `<home>/
-// crtrd.sock`. Handlers call the SAME in-process internals (spawnChild /
-// reviveNode / push / appendInbox), and brokers spawned by handlers inherit the
-// test process env (fake engine). NO product code is edited by this test.
-//
-// HONEST PROXIES (documented per criterion below):
-//  - A6 model-auth reload fan: the mtime watcher that fans `reload_auth` lives in
-//    crtrd's runDaemon(), NOT createApiServer(). Running the server in-process
-//    (not full runDaemon) means that watcher is inactive, so A6 asserts the
-//    auth.json FILE WRITE only — the plan's sanctioned substitution.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { chmodSync, statSync, existsSync, readFileSync, mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import WebSocket from 'ws';
-import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
-import { createAttachKit } from '../../../../core/__tests__/helpers/broker-clients.js';
-import { ApiError, CrtrClient } from '../../../../api/index.js';
-import { createApiServer } from '../../server.js';
-import { createNode } from '../../../../core/canvas/canvas.js';
-import { apiSocketPath } from '../../../../core/canvas/paths.js';
-import { beginExecution, recordExecutionPid } from '../../../../core/canvas/executions.js';
-import { closeTurn, openTurn } from '../../../../core/canvas/recovery.js';
-import { isPidAlive } from '../../../../core/canvas/pid.js';
-import { initializeFreshScopedStore } from '../../../../core/scoped-state/migrate.js';
-let h;
-let server;
-let client;
-let sockPath;
-const kit = createAttachKit(() => h);
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-apisrv' });
-    server = createApiServer(); // binds <h.home>/crtrd.sock (CRTR_HOME set by harness)
-    sockPath = apiSocketPath();
-    // listen() is async — the socket file appears in its callback.
-    await h.waitFor(() => existsSync(sockPath), { label: 'api socket bound', timeoutMs: 10_000 });
-    client = new CrtrClient({ socketPath: sockPath, autostart: false });
-});
-after(async () => {
-    kit.closeAll();
-    await server?.close();
-    await h?.dispose();
-});
-// Seed a non-empty assistant session so `close` takes the cancel+notice path
-// (leaving a revivable 'canceled' husk) rather than the reap-empty path (which
-// deletes the row). Mirrors cascade-close.test.ts — an empty session is reaped,
-// a non-empty one is canceled and kept.
-function seedAssistantSession(sessionFile) {
-    mkdirSync(dirname(sessionFile), { recursive: true });
-    writeFileSync(sessionFile, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
-}
-// A1 — /healthz ok + socket mode 0600
-test('A1: /healthz is ok and the unix socket is bound mode 0600', async () => {
-    const health = await client.healthz();
-    assert.equal(health.ok, true, 'GET /healthz → { ok: true }');
-    const mode = statSync(sockPath).mode & 0o777;
-    assert.equal(mode, 0o600, `socket mode is 0600 (fs-perms-as-auth), got 0o${mode.toString(8)}`);
-});
-test('status counts only live, busy non-human engine rows', async () => {
-    const agent = h.fabricateBrokerNode();
-    const deadPid = spawnSync(process.execPath, ['-e', '']).pid;
-    assert.ok(deadPid !== undefined, 'dead-pid fixture process started');
-    const deadAgent = h.fabricateBrokerNode();
-    const bridge = `human-status-${process.pid}`;
-    createNode({
-        node_id: bridge,
-        name: bridge,
-        created: new Date().toISOString(),
-        cwd: process.cwd(),
-        kind: 'human',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        host_kind: 'broker',
-        pi_pid: process.pid,
-    });
-    const baseline = (await client.status()).busy_node_count;
-    const executions = [agent, deadAgent, bridge].map((nodeId) => beginExecution(nodeId, { daemonEpoch: null }));
-    for (const [executionId, nodeId, pid] of [
-        [executions[0], agent, process.pid],
-        [executions[1], deadAgent, deadPid],
-        [executions[2], bridge, process.pid],
-    ]) {
-        recordExecutionPid(executionId, nodeId, pid);
-        openTurn(executionId, { reason: 'agent-start' });
-    }
-    try {
-        assert.equal((await client.status()).busy_node_count, baseline + 1);
-    }
-    finally {
-        for (const executionId of executions)
-            closeTurn(executionId, { endReason: 'settled' });
-    }
-});
-test('attention counts reads only the requested node slice', async () => {
-    const root = h.spawnRoot('attention root');
-    const result = await client.attentionCounts([root, 'unknown-node']);
-    assert.deepEqual(result.counts, { [root]: 0, 'unknown-node': 0 });
-});
-// A2 — POST /nodes → live node (row + broker + recorded pid), GET shows active,
-//      view.sock exists
-test('A2: POST /nodes boots a live broker; GET /nodes/{id} shows active + live pid + view.sock', async () => {
-    const root = h.spawnRoot('a2 root'); // in-process resident, pi_pid = harness pid (alive)
-    const detail = await client.createNode({ kind: 'developer', parent: root, prompt: 'a2 worker' });
-    const id = detail.node_id;
-    assert.ok(id && id !== '', 'create returns a node_id');
-    await h.awaitBoot(id); // fake-pi wrote its boot proof → broker engine is up
-    const got = await client.getNode(id);
-    assert.equal(got.status, 'active', 'GET /nodes/{id} reports active');
-    assert.ok(got.pi_pid != null && isPidAlive(got.pi_pid), 'detail carries a live recorded pid');
-    const meta = h.node(id);
-    assert.ok(meta?.pi_pid != null && isPidAlive(meta.pi_pid), 'row records a live broker pid');
-    assert.ok(existsSync(h.brokerSock(id)), 'view.sock exists for the live broker');
-});
-function installBlockedStartHook(nodeId) {
-    const root = join(h.agentHome, '.crouter', 'plugins', `blocked-start-${nodeId}`);
-    const started = join(root, 'started');
-    const release = join(root, 'release');
-    mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
-    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
-        name: `blocked-start-${nodeId}`,
-        version: '0.1.0',
-        description: 'message acknowledgment fixture',
-        hooks: 'hooks.json',
-        hookExecutable: 'bin/hook.js',
-    }));
-    writeFileSync(join(root, 'hooks.json'), JSON.stringify({
-        schemaVersion: 2,
-        lifecycle: [{ event: 'node:start', phase: 'on', op: 'block', description: 'block target launch', effects: ['waits for test release'] }],
-    }));
-    const executable = join(root, 'bin', 'hook.js');
-    mkdirSync(join(root, 'bin'), { recursive: true });
-    writeFileSync(executable, `#!/usr/bin/env node
-const { existsSync, writeFileSync } = require('node:fs');
-let input = '';
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  const request = JSON.parse(input);
-  if (request.node.id !== ${JSON.stringify(nodeId)}) {
-    process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
-    return;
-  }
-  writeFileSync(${JSON.stringify(started)}, 'started');
-  const timer = setInterval(() => {
-    if (!existsSync(${JSON.stringify(release)})) return;
-    clearInterval(timer);
-    process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
-  }, 10);
-});
-`);
-    chmodSync(executable, 0o755);
-    return { started, release };
-}
-// A3 — POST .../messages creates a durable SQL delivery; POST .../reports {tier:'final'}
-//      writes the report, notifies subscribers, transitions the row
-test('A3: messages create SQL deliveries; final report writes + notifies subscriber + transitions row', async () => {
-    const A = h.spawnRoot('a3 mgr');
-    const B = (await client.createNode({ kind: 'developer', parent: A, prompt: 'a3 worker' })).node_id;
-    await h.awaitBoot(B);
-    const msg = await client.sendMessage(B, { body: 'hello inbox' });
-    assert.equal(msg.delivered, true, 'message reports delivered');
-    await h.waitFor(() => h.inbox(B).some((entry) => entry.data?.['body'] === 'hello inbox'), { label: 'durable SQL delivery', timeoutMs: 10_000 });
-    // final report: file written + subscriber notified + row transitioned
-    const res = await client.pushReport(B, { tier: 'final', body: 'a3 done result' });
-    assert.ok(existsSync(res.report_path), `report file written at ${res.report_path}`);
-    assert.ok(res.notified.includes(A), `final push notifies the spawn-subscribed manager A (notified=${JSON.stringify(res.notified)})`);
-    assert.deepEqual(res.transitioned, { from: 'active', to: 'done' }, 'row transitioned active→done');
-    assert.equal(h.node(B)?.status, 'done', 'row status is done after final');
-    await assert.rejects(() => client.pushReport(B, { tier: 'final', delivery_tier: 'deferred', body: 'invalid tiered final' }), (error) => error instanceof ApiError && error.code === 'usage' && error.message === 'delivery_tier is only valid for update reports', 'the API rejects a delivery tier on final before it can alter final delivery');
-});
-test('A3b: a durable send acknowledges while the lifecycle tick is blocked launching its idle target', async () => {
-    const target = h.fabricateBrokerNode({ lifecycle: 'resident', status: 'idle', intent: 'idle-release' });
-    const hook = installBlockedStartHook(target);
-    const sending = client.sendMessage(target, { body: 'wake after durable acknowledgment' });
-    let tick;
-    try {
-        await h.waitFor(() => h.inbox(target).some((entry) => entry.data?.['body'] === 'wake after durable acknowledgment'), { label: 'durable SQL delivery' });
-        assert.equal(h.node(target)?.cycles ?? 0, 0, 'the send has not launched the target');
-        tick = h.tick();
-        await h.waitFor(() => existsSync(hook.started), { label: 'blocked lifecycle launch' });
-        const acknowledged = await Promise.race([
-            sending,
-            new Promise((_, reject) => setTimeout(() => reject(new Error('durable send waited for recipient launch')), 500)),
-        ]);
-        assert.equal(acknowledged.delivered, true, 'the API acknowledges the durable append');
-        assert.equal(acknowledged.revived, false, 'the response honestly reports no synchronous revive');
-        assert.equal(h.inbox(target).filter((entry) => entry.data?.['body'] === 'wake after durable acknowledgment').length, 1, 'exactly one SQL delivery is durable while launch is blocked');
-        writeFileSync(hook.release, 'release');
-        await tick;
-        assert.equal(h.node(target)?.cycles, 1, 'the one queued entry drove lifecycle revival');
-        assert.equal(h.inbox(target).filter((entry) => entry.data?.['body'] === 'wake after durable acknowledgment').length, 1, 'revival did not append a second SQL delivery');
-    }
-    finally {
-        if (!existsSync(hook.release))
-            writeFileSync(hook.release, 'release');
-        await tick;
-    }
-});
-// A4 — WS attach reconstructs the same settled broker snapshot as a direct
-//      ViewSocketClient; ?revive=0 on a dormant node → 409 without launching a broker
-test('A4a: WS attach welcome.snapshot is byte-identical to a direct ViewSocketClient snapshot', async () => {
-    const root = h.spawnRoot('a4 root');
-    const id = (await client.createNode({ kind: 'developer', parent: root, prompt: 'a4 worker' })).node_id;
-    await h.awaitBoot(id);
-    // Await the fake engine's startup turn settling before either transport is
-    // compared. `awaitBoot()` proves the process started, not that its initial
-    // prompt has stopped streaming; comparing it with a later WS welcome races
-    // two real broker instants.
-    const direct = await kit.attachUntil(id, 'observer', 'a4-direct', (attached) => attached.welcome.snapshot.state.isStreaming === false, 'settled direct broker snapshot');
-    // WS capture over the unix socket at the attach path. The node is already
-    // live+booted, so ?revive=0 is fine (the socket is listenable).
-    const wsWelcome = await new Promise((resolveWelcome, rejectWelcome) => {
-        const ws = new WebSocket(`ws+unix://${sockPath}:/v1/nodes/${id}/attach?revive=0`);
-        const timer = setTimeout(() => {
-            ws.terminate();
-            rejectWelcome(new Error('timed out waiting for WS welcome frame'));
-        }, 15_000);
-        ws.on('open', () => ws.send(JSON.stringify({ type: 'hello', role: 'observer', client_id: 'a4-ws' })));
-        ws.on('message', (data) => {
-            try {
-                const frame = JSON.parse(data.toString('utf8'));
-                if (frame['type'] === 'welcome') {
-                    clearTimeout(timer);
-                    ws.close();
-                    resolveWelcome(frame);
-                }
-            }
-            catch {
-                /* not a JSON frame — ignore */
-            }
-        });
-        ws.on('error', (err) => {
-            clearTimeout(timer);
-            rejectWelcome(err);
-        });
-    });
-    // Compare the SNAPSHOT field only (role is outside the snapshot). Both
-    // transports captured the same settled broker state.
-    assert.equal(JSON.stringify(wsWelcome.snapshot), JSON.stringify(direct.welcome.snapshot), 'WS welcome.snapshot is byte-identical to the direct ViewSocketClient snapshot');
-    direct.close();
-});
-test('A4a regression: reconnecting an observer keeps the live broker instance', async () => {
-    const root = h.spawnRoot('a4 reconnect root');
-    const id = (await client.createNode({ kind: 'developer', parent: root, prompt: 'a4 reconnect worker' })).node_id;
-    await h.awaitBoot(id);
-    const pid = h.node(id)?.pi_pid;
-    const boots = h.bootCount(id);
-    const attachOnce = () => new Promise((resolveAttach, rejectAttach) => {
-        const ws = new WebSocket(`ws+unix://${sockPath}:/v1/nodes/${id}/attach`);
-        const timer = setTimeout(() => {
-            ws.terminate();
-            rejectAttach(new Error('timed out waiting for observer welcome'));
-        }, 15_000);
-        ws.on('open', () => ws.send(JSON.stringify({ type: 'hello', role: 'observer', client_id: `a4-reconnect-${Math.random()}` })));
-        ws.on('message', (data) => {
-            if (JSON.parse(data.toString('utf8'))['type'] !== 'welcome')
-                return;
-            clearTimeout(timer);
-            ws.close();
-            resolveAttach();
-        });
-        ws.on('error', (error) => {
-            clearTimeout(timer);
-            rejectAttach(error);
-        });
-    });
-    await attachOnce();
-    await attachOnce();
-    assert.equal(h.bootCount(id), boots, 'observer reconnect did not relaunch the broker');
-    assert.equal(h.node(id)?.pi_pid, pid, 'the in-flight broker instance was retained');
-});
-test('A4b: ?revive=0 on a dormant node refuses 409 without launching a broker', async () => {
-    const root = h.spawnRoot('a4b root');
-    // A dormant row: no live broker, no pi_pid, view.sock absent.
-    const dorm = h.fabricateBrokerNode({ parent: root, status: 'active', pi_pid: null });
-    const bootsBefore = h.bootCount(dorm);
-    const status = await new Promise((resolveStatus, rejectStatus) => {
-        const ws = new WebSocket(`ws+unix://${sockPath}:/v1/nodes/${dorm}/attach?revive=0`);
-        const timer = setTimeout(() => {
-            ws.terminate();
-            rejectStatus(new Error('timed out waiting for the upgrade refusal'));
-        }, 10_000);
-        ws.on('unexpected-response', (_req, res) => {
-            clearTimeout(timer);
-            res.destroy();
-            ws.terminate();
-            resolveStatus(res.statusCode ?? 0);
-        });
-        ws.on('open', () => {
-            clearTimeout(timer);
-            ws.close();
-            rejectStatus(new Error('upgrade unexpectedly succeeded for a dormant node'));
-        });
-        ws.on('error', () => {
-            /* the refusal surfaces via unexpected-response; the trailing error is expected */
-        });
-    });
-    assert.equal(status, 409, 'dormant + ?revive=0 → HTTP 409 refusal');
-    assert.equal(h.bootCount(dorm), bootsBefore, 'no broker was launched (boot count unchanged)');
-    assert.equal(h.node(dorm)?.pi_pid ?? null, null, 'no pid recorded — the node stayed dormant');
-});
-// A5 — POST .../close tears down the broker + cascades per edges
-test('A5: close tears down the target broker and cascades its subtree, leaving the ancestor untouched', async () => {
-    const A = h.spawnRoot('a5 root');
-    const B = (await client.createNode({ kind: 'developer', parent: A, prompt: 'a5 mid' })).node_id;
-    await h.awaitBoot(B);
-    const C = (await client.createNode({ kind: 'developer', parent: B, prompt: 'a5 leaf' })).node_id;
-    await h.awaitBoot(C);
-    // Non-empty sessions → close leaves revivable 'canceled' husks (not reaped).
-    for (const id of [B, C]) {
-        const sessionFile = h.node(id)?.pi_session_file;
-        assert.ok(sessionFile != null, `${id} has a session file`);
-        seedAssistantSession(sessionFile);
-    }
-    const result = await client.closeNode(B);
-    assert.equal(result.root, B, 'close result names B as the cascade root');
-    assert.deepEqual([...result.closed].sort(), [B, C].sort(), 'B and its child C are the closed set');
-    assert.deepEqual(result.spared, [], 'nothing spared');
-    // Broker engines for B and C are torn down (pid gone / not alive).
-    for (const id of [B, C]) {
-        await h.waitFor(() => {
-            const pid = h.node(id)?.pi_pid ?? null;
-            return pid === null || !isPidAlive(pid);
-        }, { label: `${id} broker torn down by close`, timeoutMs: 20_000 });
-    }
-    assert.equal(h.node(B)?.status, 'canceled', 'B is canceled');
-    assert.equal(h.node(C)?.status, 'canceled', 'cascaded child C is canceled');
-    assert.equal(h.node(A)?.status, 'active', 'ancestor A is untouched (still active)');
-});
-// A6 — PUT /profiles/{name} idempotent; PUT /model-auth/{provider} writes
-//      auth.json (sandboxed PI_CODING_AGENT_DIR).
-//      HONEST PROXY: reload fan is asserted as the file write only (the mtime
-//      watcher lives in runDaemon, not createApiServer).
-test('A6a: PUT /profiles/{name} is idempotent (twice → same profile id)', async () => {
-    // Profiles write under `join(homedir(), '.crouter', 'profiles')` — homedir()
-    // honors HOME, which the harness only overrides for SUBPROCESS children. For
-    // our in-process handler calls, isolate HOME to the harness's agentHome.
-    const savedHome = process.env['HOME'];
-    process.env['HOME'] = h.agentHome;
-    try {
-        const p1 = await client.ensureProfile('a6prof');
-        const p2 = await client.ensureProfile('a6prof');
-        assert.ok(p1.id && p1.id !== '', 'profile has a stable id');
-        assert.equal(p2.id, p1.id, 'a re-PUT of the same name returns the same profile id (idempotent)');
-        assert.equal(p2.name, 'a6prof', 'profile name round-trips');
-    }
-    finally {
-        if (savedHome === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = savedHome;
-    }
-});
-test('A6b: PUT /model-auth/{provider} writes auth.json (reload fan asserted as file write — honest proxy)', async () => {
-    // Sandbox pi's credential store so the write lands in a throwaway dir, never
-    // the developer's real ~/.pi/agent/auth.json.
-    const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
-    const piDir = mkdtempSync(join(tmpdir(), 'crtr-apisrv-pi-'));
-    process.env['PI_CODING_AGENT_DIR'] = piDir;
-    initializeFreshScopedStore({ kind: 'provider', root: piDir });
-    try {
-        const res = await client.installCredential('anthropic', { kind: 'api_key', api_key: 'sk-test-xyz' });
-        assert.equal(res.installed, true, 'credential reports installed');
-        assert.equal(res.managed, false, 'api_key install is not a managed-pool account');
-        const authFile = join(piDir, 'auth.json');
-        assert.ok(existsSync(authFile), 'auth.json was written to the sandboxed PI_CODING_AGENT_DIR');
-        const contents = readFileSync(authFile, 'utf8');
-        assert.ok(contents.includes('sk-test-xyz') || contents.includes('anthropic'), 'auth.json carries the installed credential material');
-        // HONEST PROXY: the `reload_auth` fan is driven by crtrd's runDaemon() mtime
-        // watcher, not createApiServer(); with the server run in-process that watcher
-        // is inactive, so we assert only the durable file write (plan's sanctioned
-        // substitution).
-    }
-    finally {
-        if (savedPiDir === undefined)
-            delete process.env['PI_CODING_AGENT_DIR'];
-        else
-            process.env['PI_CODING_AGENT_DIR'] = savedPiDir;
-        rmSync(piDir, { recursive: true, force: true });
-    }
-});
-// /v1/files/peek — host file read (capped → `truncated`), plus the
-// usage/relative/404 error mapping. Covers the handler's non-trivial
-// branching (usage / notFound / directory / truncation boundary).
-const PEEK_CAP = 512 * 1024; // MUST mirror PEEK_MAX_BYTES in handlers/files.ts
-test('files/peek: 200 returns full content, untruncated, for a small file', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-peek-'));
-    try {
-        const file = join(dir, 'hello.txt');
-        writeFileSync(file, 'peek me');
-        const res = await client.peekFile(file);
-        assert.equal(res.path, file, 'echoes the absolute path back');
-        assert.equal(res.content, 'peek me', 'returns the full file content');
-        assert.equal(res.truncated, false, 'a small file is not flagged truncated');
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('files/peek: truncation boundary — exactly at cap is whole; one byte over truncates', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'crtr-peek-'));
-    try {
-        // Exactly at the cap: read min(size,cap)+1 yields bytesRead === cap, so NOT
-        // flagged truncated, and the full content is returned.
-        const atCap = join(dir, 'at-cap.bin');
-        writeFileSync(atCap, 'a'.repeat(PEEK_CAP));
-        const atRes = await client.peekFile(atCap);
-        assert.equal(atRes.truncated, false, 'a file exactly at the cap is not truncated');
-        assert.equal(atRes.content.length, PEEK_CAP, 'full content returned at the cap');
-        // One byte over: bytesRead === cap+1 > cap ⇒ truncated, content clipped to cap.
-        const overCap = join(dir, 'over-cap.bin');
-        writeFileSync(overCap, 'a'.repeat(PEEK_CAP + 1));
-        const overRes = await client.peekFile(overCap);
-        assert.equal(overRes.truncated, true, 'bytesRead > cap ⇒ truncated:true');
-        assert.equal(overRes.content.length, PEEK_CAP, 'content is clipped to exactly the cap');
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test('files/peek: 400-usage (missing + relative) and 404 error mapping', async () => {
-    await assert.rejects(client.peekFile(''), (e) => e instanceof ApiError && e.status === 400 && e.code === 'usage', 'missing path → 400 usage');
-    await assert.rejects(client.peekFile('relative/not/absolute.txt'), (e) => e instanceof ApiError && e.status === 400 && e.code === 'usage', 'relative path → 400 usage');
-    await assert.rejects(client.peekFile(join(tmpdir(), 'crtr-peek-does-not-exist-xyz', 'nope.txt')), (e) => e instanceof ApiError && e.status === 404 && e.code === 'not_found', 'nonexistent absolute path → 404 not_found');
-});

package/dist/daemon/api/__tests__/seam/b10-attach-modelauth.test.d.ts

@@ -1 +0,0 @@
-export {};