@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/__tests__/human-deliver-e2e.test.js

@@ -1,38 +1,27 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/human-deliver-e2e.test.ts
 //
-// M2 e2e — drive a REAL completion through the REGISTERED crouter handler as a
-// SUBPROCESS, not in-process. This exercises the whole cutover seam that the
-// in-process human-deliver.test.ts stubs out with a benign handler:
-//   registerInboxRoot(crouterDeliverHandler()) → submitDeck → claim →
-//   completeDeck → humanloop spawns `crouterCliEntry human _deliver` on stdin →
-//   that CLI subprocess reads the canvas DB at the temp CRTR_HOME, pushFinals
-//   the envelope to the parent, and exits 0.
-//
-// crouterDeliverHandler() resolves the runnable CLI entry from the loaded
-// shared.ts location. Under `tsx`, that is `src/cli.ts` via the tsx ESM loader
-// (dist/cli.js is not a sibling of src/); either entry is a real subprocess that
-// must resolve the canvas at CRTR_HOME, which humanloop's dispatch inherits from
-// this process's env.
+// Drive a terminal ticket through the public crtrd ticket route. Terminal
+// delivery is daemon-owned; no subprocess handler or delivery receipt exists.
 import { test, before, beforeEach, afterEach, after } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, realpathSync, existsSync } from 'node:fs';
+import { mkdtempSync, existsSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { ApiError, CrtrClient } from '../../api/index.js';
 import { createApiServer } from '../../daemon/api/server.js';
 import { apiSocketPath } from '../canvas/paths.js';
-import { registerInboxRoot, submitDeck, validateDeck, claimTicket, completeDeck, atomicWriteJson, } from '@crouton-kit/humanloop';
-import { crouterDeliverHandler } from '../../commands/human/shared.js';
+import { validateDeck } from '../human/deck-schema.js';
+import { claimTicket, readTicketClaim } from '../human/claim.js';
+import { ticketDir } from '../human/root.js';
+import { submitDeck, submitReview } from '../human/tickets.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { getNode, closeDb } from '../canvas/index.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { resolveRef } from '../canvas/history.js';
 let home;
-let stateHome;
-let root;
 let priorHome;
 let server;
-// createApiServer binds its socket asynchronously (file created in the listen
-// callback); poll for it before the subprocess handler tries to connect.
+let client;
 async function waitForSocket(path) {
     for (let i = 0; i < 200; i++) {
         if (existsSync(path))
@@ -47,22 +36,12 @@ before(() => {
 beforeEach(async () => {
     closeDb();
     home = mkdtempSync(join(tmpdir(), 'crtr-e2e-home-'));
-    stateHome = mkdtempSync(join(tmpdir(), 'crtr-e2e-state-'));
-    const rootDir = mkdtempSync(join(tmpdir(), 'crtr-e2e-root-'));
     process.env['CRTR_HOME'] = home;
     process.env['HOME'] = home;
-    process.env['XDG_STATE_HOME'] = stateHome;
     delete process.env['CRTR_NODE_ID'];
-    // POST-P1 the `crtr human _deliver` subprocess humanloop spawns pushFinals
-    // through cliClient() over crtrd's socket. Bind an in-process createApiServer()
-    // on this temp home's socket (apiSocketPath() resolves under CRTR_HOME=home)
-    // so the subprocess's client resolves against the same tmp canvas DB. Closed
-    // in afterEach.
     server = createApiServer();
     await waitForSocket(apiSocketPath());
-    // Register with the REAL crouter completion handler — this is what humanloop
-    // will spawn as a subprocess on resolution.
-    root = registerInboxRoot({ root: realpathSync(rootDir), owner: 'crouter', handler: crouterDeliverHandler() }).root;
+    client = new CrtrClient({ socketPath: apiSocketPath(), autostart: false });
 });
 afterEach(async () => {
     await server?.close();
@@ -76,48 +55,69 @@ after(() => {
     else
         delete process.env['HOME'];
     delete process.env['CRTR_HOME'];
-    delete process.env['XDG_STATE_HOME'];
     delete process.env['CRTR_NODE_ID'];
 });
+async function expectBadResolve(nodeId, body) {
+    await assert.rejects(() => client.request('POST', `/v1/human/tickets/${nodeId}/resolve`, body), (error) => error instanceof ApiError && error.status === 400 && error.code === 'invalid_request' && !error.message.includes('POST /v1/human/reviews/:review_id/submit'));
+}
+async function expectReviewSubmitGuidance(nodeId, body) {
+    await assert.rejects(() => client.request('POST', `/v1/human/tickets/${nodeId}/resolve`, body), (error) => error instanceof ApiError && error.status === 400 && error.code === 'invalid_request' && error.message.includes('POST /v1/human/reviews/:review_id/submit'));
+}
 function reportBody(ref) {
     const resolved = resolveRef(ref);
     if (resolved === null || resolved.source !== 'report')
         throw new Error(`push report ref did not resolve to a report: ${ref}`);
     return resolved.body;
 }
-test('a real completeDeck dispatches the registered crouter CLI subprocess, which pushFinals the readable answer to the parent', async () => {
+test('malformed resolves leave the mounted ticket claim in place', async () => {
+    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
+    const deckBridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-deck', lifecycle: 'terminal' }).node_id;
+    const deckDir = ticketDir(deckBridge);
+    submitDeck({
+        dir: deckDir,
+        deck: validateDeck({
+            title: 'Ship it?',
+            interactions: [{ id: 'question', title: 'Ship it?', subtitle: 'Decide whether to ship now so the release can proceed.', options: [], allowFreetext: true }],
+        }),
+    });
+    const deckClaim = claimTicket(deckDir);
+    assert.ok(deckClaim !== null);
+    for (const body of [{ responses: [null] }, { response: [] }, { responses: [], debug: true }]) {
+        await expectBadResolve(deckBridge, body);
+        assert.equal(readTicketClaim(deckDir)?.token, deckClaim.token, 'malformed deck input must not take over the live claim');
+    }
+    for (const body of [{ responses: [], feedback: {} }, { feedback: [] }]) {
+        await expectReviewSubmitGuidance(deckBridge, body);
+        assert.equal(readTicketClaim(deckDir)?.token, deckClaim.token, 'feedback-shaped input must not take over the live claim');
+    }
+    const reviewBridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-review', lifecycle: 'terminal' }).node_id;
+    const reviewDir = ticketDir(reviewBridge);
+    const file = join(home, 'review.md');
+    writeFileSync(file, '# Review\n');
+    submitReview({ dir: reviewDir, review: { title: 'Review', subtitle: 'Review this file so implementation can proceed safely.', source: {}, file } });
+    const reviewClaim = claimTicket(reviewDir);
+    assert.ok(reviewClaim !== null);
+    await expectReviewSubmitGuidance(reviewBridge, { responses: [] });
+    assert.equal(readTicketClaim(reviewDir)?.token, reviewClaim.token, 'review ticket resolve must not take over the live claim');
+});
+test('the ticket resolve route pushFinals the readable answer to the parent', async () => {
     const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
     const bridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-ask', lifecycle: 'terminal' }).node_id;
-    const dir = join(root, bridge);
-    mkdirSync(dir, { recursive: true });
-    atomicWriteJson(join(dir, 'run.json'), { mode: 'ask', job_id: bridge });
-    const deck = validateDeck({ title: 'Ship it?', interactions: [{ id: 'question', title: 'Ship it?', subtitle: 'Decide whether to ship now so the release can proceed.', options: [], allowFreetext: true }] });
-    submitDeck({ root, id: bridge, deck });
-    const claim = claimTicket(dir);
-    assert.ok(claim !== null, 'claimed the fresh ticket');
-    // Release the test process's DB handle so the spawned handler subprocess has
-    // clean access to the temp canvas at CRTR_HOME.
-    closeDb();
-    const { won } = await completeDeck(dir, [{ id: 'question', freetext: 'yes, ship' }], claim.token);
-    assert.equal(won, true, 'completeDeck won');
-    // humanloop writes delivery.json only after the handler exits 0.
-    assert.ok(existsSync(join(dir, 'delivery.json')), 'the handler subprocess acked delivery (exit 0)');
-    assert.ok(!existsSync(join(dir, 'delivery-error.json')), 'no delivery error');
-    // The subprocess pushFinal'd through the real CLI: bridge finalized + parent inbox has the answer.
-    assert.equal(getNode(bridge)?.status, 'done', 'bridge finalized by the subprocess handler');
-    const finals = readInboxSince(parent).filter((e) => e.from === bridge && e.kind === 'final');
-    assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent via the subprocess');
+    const dir = ticketDir(bridge);
+    submitDeck({
+        dir,
+        deck: validateDeck({
+            title: 'Ship it?',
+            interactions: [{ id: 'question', title: 'Ship it?', subtitle: 'Decide whether to ship now so the release can proceed.', options: [], allowFreetext: true }],
+        }),
+    });
+    const result = await client.resolveHumanTicket(bridge, { responses: [{ id: 'question', freetext: 'yes, ship' }] });
+    assert.deepEqual(result, { delivered: true, kind: 'deck' });
+    assert.equal(getNode(bridge)?.status, 'done', 'bridge finalized by crtrd');
+    const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
+    assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
     const body = reportBody(finals[0].ref);
-    assert.ok(body.includes('yes, ship'), "the human's answer is inline");
-    assert.ok(body.includes(join(dir, 'response.json')), 'the canonical response path is one path away');
-    assert.ok(!body.includes('humanloop.response/v2'), 'no serialized envelope is inlined');
-});
-test('the registered handler argv is an absolute, cwd-independent runnable CLI entry', () => {
-    const handler = crouterDeliverHandler();
-    assert.equal(handler.command, process.execPath);
-    // Last two args are always the subcommand path.
-    assert.deepEqual(handler.args.slice(-2), ['human', '_deliver']);
-    // The CLI entry is an existing absolute file (dist/cli.js when built, else src/cli.ts under tsx).
-    const entry = handler.args.find((a) => a.endsWith('cli.js') || a.endsWith('cli.ts'));
-    assert.ok(entry !== undefined && entry.startsWith('/') && existsSync(entry), `handler CLI entry must be an existing absolute path: ${entry}`);
+    assert.ok(body.includes('yes, ship'));
+    assert.ok(body.includes(join(dir, 'response.json')));
+    assert.ok(!body.includes('humanloop.response/v2'));
 });