@north-light/crouter 0.3.169 → 0.3.170

package/dist/commands/human/prompts.js

@@ -8,12 +8,12 @@ import { InputError } from '../../core/io.js';
 import { cliClient } from '../api-client.js';
 import { nodeDir } from '../../core/canvas/paths.js';
 import { mkdirSync, existsSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { tmuxServerReachable } from '../../core/spawn.js';
 import { BrokerClient, BrokerUnavailableError } from '../../core/broker-client/index.js';
 import { markStopSignal } from '../../core/runtime/stop-signals.js';
-import { validateDeck, notifyDeck, atomicWriteJson, submitDeck, submitReview, display, } from '@crouton-kit/humanloop';
+import { validateDeck, resolveDeckBodyPaths, notifyDeck, atomicWriteJson, submitDeck, submitReview, display, } from '@crouton-kit/humanloop';
 import { BODY_PATH_CONTRACT, DECK_SCHEMA_HINT, registerCrouterRoot, resolveMaxPanes } from './shared.js';
 import { inboxOpenInstruction, inboxPopupHint } from '../../core/keybindings/index.js';
 /** The asking node's id, or null when run from a bare shell (no parent to route to). */
@@ -54,14 +54,22 @@ function requireSubtitle(subtitle, field = 'subtitle') {
         next: 'Write one plain-English sentence stating the decision, recommendation or status, and stakes.',
     });
 }
-function validateTitledDeck(input) {
+function validateTitledDeck(input, deckDirectory) {
     const title = typeof input === 'object' && input !== null
         ? input.title
         : undefined;
     if (typeof title !== 'string' || title.trim() === '') {
         throw new Error('deck title is required');
     }
-    return validateDeck(input);
+    const deck = validateDeck(input);
+    if (deckDirectory === undefined)
+        return deck;
+    for (const interaction of deck.interactions) {
+        if (interaction.bodyPath !== undefined && isAbsolute(interaction.bodyPath)) {
+            throw new Error('bodyPath must be relative to the deck JSON; absolute paths are unsupported');
+        }
+    }
+    return resolveDeckBodyPaths(deck, deckDirectory);
 }
 function buildHumanAskDeck(title, subtitle, question) {
     return validateTitledDeck({
@@ -172,7 +180,7 @@ export const humanAsk = defineLeaf({
             `Returns immediately; nothing opens on screen. The human answers from the inbox popup (${inboxPopupHint()}) on their own time.`,
         ],
     },
-    run: async (input) => {
+    run: async (input, context) => {
         // Optional stdin reaches the leaf as an empty string when omitted, including
         // when --context-file is supplied. Keep the raw non-empty bytes untouched.
         const titleRaw = input['title'];
@@ -182,6 +190,7 @@ export const humanAsk = defineLeaf({
         const subtitleRaw = input['subtitle'];
         const subtitle = typeof subtitleRaw === 'string' && subtitleRaw.trim() !== '' ? subtitleRaw.trim() : undefined;
         const deckInput = input['deck'];
+        const deckPath = context?.contextFilePaths.get('deck');
         if (deckInput !== undefined && (question !== undefined || titleRaw !== undefined || subtitleRaw !== undefined)) {
             throw new InputError({
                 error: 'bad_invocation',
@@ -205,7 +214,7 @@ export const humanAsk = defineLeaf({
                 deck = buildHumanAskDeck(simpleAsk.title, simpleAsk.subtitle, simpleAsk.question);
             }
             else {
-                deck = validateTitledDeck(deckInput);
+                deck = validateTitledDeck(deckInput, deckPath === undefined ? undefined : dirname(deckPath));
             }
             deck = canonicalizeAskKinds(deck);
         }

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

@@ -16,17 +16,20 @@ import { test, describe, before, after, beforeEach, afterEach } from 'node:test'
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, realpathSync, readFileSync, existsSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join, basename } from 'node:path';
+import { dirname, join, resolve, basename } from 'node:path';
+import { Readable } from 'node:stream';
 import { registerInboxRoot, submitDeck, validateDeck, claimTicket, completeDeck, cancelTicket, readTicketResult, atomicWriteJson, } from '@crouton-kit/humanloop';
 import { spawnNode } from '../runtime/nodes.js';
 import { getNode, listNodes, closeDb } from '../canvas/index.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { humanAsk, humanReview, humanNotify } from '../../commands/human/prompts.js';
+import { runCli } from '../command.js';
 import { resolveRef } from '../canvas/history.js';
 import { humanDeliver } from '../../commands/human/queue.js';
 import { createApiServer } from '../../daemon/api/server.js';
 import { trustedCrouterVisualHandler } from '../../daemon/api/handlers/human.js';
-import { apiSocketPath } from '../canvas/paths.js';
+import { apiSocketPath, nodeDir } from '../canvas/paths.js';
+import { resolveRoot } from '../../build-root.js';
 // ---------------------------------------------------------------------------
 // Isolated environment
 // ---------------------------------------------------------------------------
@@ -57,6 +60,28 @@ const ISO = '2026-07-10T12:00:00.000Z';
 function benignHandler() {
     return { command: process.execPath, args: ['-e', ''] };
 }
+async function withPipedStdin(body, fn) {
+    const original = process.stdin;
+    const stdin = Readable.from([Buffer.from(body)]);
+    Object.defineProperty(stdin, 'isTTY', { value: false, configurable: true });
+    Object.defineProperty(process, 'stdin', { value: stdin, configurable: true });
+    try {
+        return await fn();
+    }
+    finally {
+        Object.defineProperty(process, 'stdin', { value: original, configurable: true });
+    }
+}
+async function withMutedStdout(fn) {
+    const originalWrite = process.stdout.write;
+    process.stdout.write = (() => true);
+    try {
+        return await fn();
+    }
+    finally {
+        process.stdout.write = originalWrite;
+    }
+}
 /** Register `dir` (created fresh) as an owner-'crouter' root and return its
  *  canonical path. */
 function registerRoot(dir) {
@@ -172,6 +197,41 @@ describe('enqueue is producer-only', () => {
         }));
         const structuredDeck = JSON.parse(readFileSync(join(structured['dir'], 'deck.json'), 'utf8'));
         assert.deepEqual(structuredDeck.interactions.map((interaction) => interaction.kind), ['decision', 'context']);
+        const deckDir = mkdtempSync(join(tmpdir(), 'crtr-context-file-deck-'));
+        assert.notEqual(resolve(process.cwd()), deckDir, 'the CLI caller cwd must differ from the deck directory');
+        const deckPath = join(deckDir, 'deck.json');
+        writeFileSync(join(deckDir, 'body.md'), 'The body came from beside the deck JSON.');
+        writeFileSync(deckPath, JSON.stringify({
+            title: 'Context file body',
+            interactions: [{
+                    id: 'decision',
+                    title: 'Use the deck',
+                    subtitle: 'Use the deck body so the person can decide with its context.',
+                    bodyPath: 'body.md',
+                    options: [{ id: 'yes', label: 'Yes' }],
+                }],
+        }));
+        const nodesBeforeContextFile = new Set(listNodes().map((node) => node.node_id));
+        await withMutedStdout(() => withPipedStdin('', async () => {
+            await runCli(await resolveRoot('human'), ['node', 'crtr', 'human', 'ask', '--context-file', deckPath]);
+        }));
+        const contextFileBridge = listNodes().find((node) => !nodesBeforeContextFile.has(node.node_id));
+        assert.ok(contextFileBridge, 'the real CLI invocation created a human bridge');
+        const contextFileDeck = JSON.parse(readFileSync(join(nodeDir(contextFileBridge.node_id), 'deck.json'), 'utf8'));
+        assert.equal(contextFileDeck.interactions[0]?.body, 'The body came from beside the deck JSON.');
+        assert.equal(contextFileDeck.interactions[0]?.bodyPath, undefined);
+        await assert.rejects(() => humanAsk.run({
+            deck: {
+                title: 'Absolute path',
+                interactions: [{
+                        id: 'decision',
+                        title: 'Reject absolute path',
+                        subtitle: 'Reject the invalid path so the documented deck boundary remains intact.',
+                        bodyPath: join(deckDir, 'body.md'),
+                        options: [{ id: 'yes', label: 'Yes' }],
+                    }],
+            },
+        }, { providedParams: new Set(['deck']), contextFilePaths: new Map([['deck', deckPath]]) }), /absolute paths are unsupported/);
         const rc = JSON.parse(readFileSync(join(r['dir'], 'run.json'), 'utf8'));
         assert.equal(rc['mode'], 'ask');
         assert.equal(rc['job_id'], r['job_id']);

package/dist/core/command.d.ts

@@ -12,6 +12,11 @@ export interface LeafRunContext {
      *  as a positional argument, or explicitly passed; absence means TTY with no
      *  pipe (truly absent). */
     readonly providedParams: ReadonlySet<string>;
+    /** Absolute source paths for JSON values supplied through `--context-file`,
+     *  keyed by their camel-cased parameter name. The parsed JSON remains the
+     *  leaf input; this metadata preserves its source directory for values that
+     *  reference adjacent files. */
+    readonly contextFilePaths: ReadonlyMap<string, string>;
 }
 /** Opt-in flag that surfaces a node as an editor slash command (a pi prompt
  *  template / Claude Code command). When set, the bootstrap auto-writes a
@@ -149,6 +154,9 @@ export interface ParseArgvOptions {
      *  Called once with a ReadonlySet of parameter names that were supplied by
      *  the caller (distinct from defaulted or missing values). */
     onProvidedParams?: (provided: ReadonlySet<string>) => void;
+    /** Optional collector for absolute source paths of JSON values supplied via
+     *  `--context-file`, keyed by their camel-cased parameter name. */
+    onContextFilePaths?: (paths: ReadonlyMap<string, string>) => void;
     /** The walked command path (e.g. `['push','final']`), supplied by the
      *  dispatcher. Used only to name the exact leaf in a schema-class error's
      *  `Next:` line, which mandates reading that leaf's `-h`. */

package/dist/core/command.js

@@ -14,6 +14,7 @@ import { readFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { constants as osConstants } from 'node:os';
 import { isatty } from 'node:tty';
+import { resolve } from 'node:path';
 // ---------------------------------------------------------------------------
 // Factory functions
 // ---------------------------------------------------------------------------
@@ -268,6 +269,7 @@ function flagNameToKey(name) {
 export async function parseArgv(params, tokens, options) {
     const result = {};
     const provided = new Set(); // Track explicitly-provided parameter names
+    const contextFilePaths = new Map();
     // Index params by kind for quick lookup
     const positionalParam = params.find((p) => p.kind === 'positional');
     const stdinParam = params.find((p) => p.kind === 'stdin');
@@ -332,6 +334,7 @@ export async function parseArgv(params, tokens, options) {
                 }
                 const contextFileKey = flagNameToKey(contextFileParam.name);
                 result[contextFileKey] = parsed;
+                contextFilePaths.set(contextFileKey, resolve(pathVal));
                 provided.add(contextFileKey);
                 i++;
                 continue;
@@ -539,6 +542,9 @@ export async function parseArgv(params, tokens, options) {
     if (options?.onProvidedParams !== undefined) {
         options.onProvidedParams(provided);
     }
+    if (options?.onContextFilePaths !== undefined) {
+        options.onContextFilePaths(contextFilePaths);
+    }
     return result;
 }
 export async function runCli(root, argv, options) {
@@ -618,13 +624,17 @@ export async function runCli(root, argv, options) {
         const leaf = node;
         const params = leaf.help.params !== undefined ? leaf.help.params : [];
         let providedParams = new Set();
+        let contextFilePaths = new Map();
         const input = await parseArgv(params, remaining, {
             leafPath: path,
             onProvidedParams: (provided) => {
                 providedParams = provided;
             },
+            onContextFilePaths: (paths) => {
+                contextFilePaths = paths;
+            },
         });
-        const context = { providedParams };
+        const context = { providedParams, contextFilePaths };
         const result = await operationIdContext.fresh(() => leaf.run(input, context));
         if (result !== undefined && result !== null) {
             if (isJsonOutput()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.169",
+  "version": "0.3.170",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.169",
+  "version": "0.3.170",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.169",
+      "version": "0.3.170",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {