@north-light/crouter 0.3.173 → 0.3.175

package/dist/clients/web/web-client/shared/protocol.d.ts

@@ -1,214 +0,0 @@
-/**
- * Shared wire types for the crouter web client/server split.
- *
- * The SPA imports the pi payload types it needs from this module — never from
- * broker-protocol internals. The type-only re-exports below keep the web
- * package's shared payload shapes in one place.
- */
-export type { UserMessage, AssistantMessage, ToolResultMessage, TextContent, ToolCall, ImageContent, } from '@earendil-works/pi-ai';
-export type { ThinkingLevel } from '@earendil-works/pi-agent-core';
-export type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcSessionState, } from '@earendil-works/pi-coding-agent';
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
-import type { RpcSessionState } from '@earendil-works/pi-coding-agent';
-import type { DeterministicCommandExpansion } from '../../../../core/runtime/command-expansion.js';
-/**
- * An `AgentMessage` enriched with a client-side origin tag.
- * Only `role:'user'` messages can carry `origin:'inbox'`; all others leave
- * `origin` undefined. `'human'` is reserved for future explicit human-origin
- * tagging (currently unset — absence means human by default).
- *
- * Defined as an intersection (not `interface extends`) because `AgentMessage`
- * is a union type and TypeScript does not allow extending unions.
- */
-export type FoldedMessage = AgentMessage & {
-    /** Set to `'inbox'` when this user message is recognized as injected by the
-     *  canvas-inbox-watcher extension (a coalesced inbox digest). */
-    origin?: 'inbox' | 'human';
-};
-/** base session vs orchestrator. */
-export type NodeMode = 'base' | 'orchestrator';
-/** terminal (reaps when done) vs resident (root) node. */
-export type NodeLifecycle = 'terminal' | 'resident';
-/** Canvas lifecycle status. */
-export type NodeLifeStatus = 'active' | 'idle' | 'done' | 'dead' | 'canceled';
-/** broker-hosted (enterable) vs tmux-pane (shown, non-enterable). */
-export type HostKind = 'broker' | 'tmux';
-/** One row from `crtr canvas snapshot --json` — node identity + runtime, no chrome. */
-export interface NodeSummary {
-    node_id: string;
-    name: string;
-    /** Node kind (developer/explore/…) — open set. */
-    kind: string;
-    mode: NodeMode;
-    lifecycle: NodeLifecycle;
-    status: NodeLifeStatus;
-    cwd: string;
-    /** Spine parent node id, or null for a root. */
-    parent: string | null;
-    /** ISO-8601 creation timestamp. */
-    created: string;
-    host_kind: HostKind;
-    /** True iff `host_kind === 'broker'` (the web UI can open a live session). */
-    enterable: boolean;
-    /** Count of pending human asks (blocked-on-human indicator). */
-    attention_count: number;
-    /** Canvas cycle count for this node (revive/yield generations). Optional for
-     *  back-compat with snapshots produced before the field existed. */
-    cycles?: number;
-    /** ISO-8601 of the node's most recent work (session activity), distinct from
-     *  `created`. Optional/back-compat; falls back to `created` when absent. */
-    last_activity?: string;
-}
-/** input/output token burn, with cache reads where the provider reports them. */
-export interface TokenBurn {
-    input: number;
-    output: number;
-    cache?: number;
-}
-/** Live context-window usage. */
-export interface ContextUsage {
-    tokens: number;
-    window: number;
-    percent: number;
-}
-/** Coarse session stats for chrome (distinct from pi's full `SessionStats`). */
-export interface SessionStatsSummary {
-    turns: number;
-    user_messages: number;
-    assistant_messages: number;
-    cost?: number;
-}
-/** Viewer presence for a node — a truthful count of attached views. There is
- *  no owner: every live interactive view is writable at the same time. */
-export interface Presence {
-    viewers: number;
-}
-/** Git working-tree change counts for the meta strip. */
-export interface GitStatus {
-    added: number;
-    modified: number;
-    deleted: number;
-    untracked: number;
-}
-/** `crtr node inspect show --json`'s node payload — `NodeSummary` plus the per-node chrome. */
-export interface NodeDetail extends NodeSummary {
-    branch: string | null;
-    model: string | null;
-    tokens: TokenBurn | null;
-    context: ContextUsage | null;
-    tool_calls: number | null;
-    stats: SessionStatsSummary | null;
-    presence: Presence | null;
-    /** True while a broker is live; false for a dormant (last-known) view. */
-    live: boolean;
-    /** Working-tree change counts for the meta strip (null when unavailable). */
-    git_status?: GitStatus | null;
-}
-/** A slash command in a node's palette (from the broker `get_commands` reply). */
-export interface Command {
-    name: string;
-    description: string;
-    source: 'builtin' | 'command' | 'template';
-    location?: 'user' | 'project' | 'path';
-    path?: string;
-    argument_hint?: string;
-    /** Raw file-template body used to disclose the exact expanded prompt before submission. */
-    template?: string;
-    /** Deterministic extension-command prompt expansion; absent for immediate UI,
-     * dynamic, and side-effect commands. */
-    expansion?: DeterministicCommandExpansion;
-}
-/** Metadata for one resolvable inline memory reference (design: inline memory
- *  references). Hand-mirrored field-for-field from `RefMeta` in
- *  `core/runtime/broker-protocol.ts` rather than imported — this module stays
- *  free of any dependency on broker-protocol so it can be shared by both the
- *  browser bundle and server-side code (browser convention, D11). `name` is
- *  the canonical name a token resolves to and what `crtr memory read <name>`
- *  expects; `scope` is the winning scope after precedence dedup (display
- *  only). Metadata only — no document body or source path. */
-export interface RefMeta {
-    name: string;
-    kind: 'knowledge' | 'preference';
-    scope: 'node' | 'project' | 'profile' | 'user' | 'builtin';
-    shortForm: string;
-}
-/** `crtr canvas snapshot --json` body. */
-export interface CanvasSnapshot {
-    nodes: NodeSummary[];
-    /** ISO-8601. */
-    generated_at: string;
-}
-/** `crtr node new --json` success. */
-export interface SpawnResponse {
-    node_id: string;
-    name: string;
-    window?: string;
-    session?: string;
-    status: string;
-    follow_up: string;
-}
-/** `crtr node message send --json` success. */
-export interface MessageResponse {
-    mode: string;
-    armed: boolean;
-    target: string;
-    delivered?: boolean;
-    revived?: boolean;
-    guidance: string;
-}
-/** `crtr node lifecycle revive --json` success. */
-export interface ReviveResponse {
-    window: null;
-    session: string | null;
-    resumed: boolean;
-    ready: boolean;
-}
-/** `crtr node lifecycle close --json` success. */
-export interface CloseResponse {
-    closed: boolean;
-    node_id: string;
-    count: number;
-    closed_ids: string[];
-    spared: string[];
-}
-/** `crtr node new` body. Always headless; `root` toggles a resident node. */
-export interface SpawnRequest {
-    prompt: string;
-    kind: string;
-    mode?: NodeMode;
-    root?: boolean;
-    cwd?: string;
-    name?: string;
-    model?: string;
-    parent?: string;
-}
-/** `crtr node message send` body. */
-export interface MessageRequest {
-    body: string;
-    tier?: string;
-}
-/** `crtr node lifecycle revive` body. */
-export interface ReviveRequest {
-    fresh?: boolean;
-}
-/**
- * Engine state carried in `snapshot.state` — pi's OWN `get_state` payload, not a
- * mirror of it. `BrokerSnapshot['state']` is this same type, so the welcome frame
- * passes through the SPA untranslated. The SPA's streaming/idle indicator reads
- * `isStreaming` (spec C.10).
- */
-export type SessionState = RpcSessionState;
-/** Fixed capability of one browser tab's session connection, stated by the
- *  broker's `welcome`: `controller` is writable, `observer` is read-only. It is
- *  a per-client capability, never ownership of a shared slot. */
-export type WebRole = 'observer' | 'controller';
-/** Upstream broker connectivity, surfaced to the tab (spec §6.2). */
-export type BrokerStatus = 'connected' | 'reconnecting' | 'down' | 'revived';
-/** Response payload to an extension dialog (`RpcExtensionUIResponse` minus id/type). */
-export type DialogResponseValue = {
-    value: string;
-} | {
-    confirmed: boolean;
-} | {
-    cancelled: true;
-};

package/dist/clients/web/web-client/shared/protocol.js

@@ -1,8 +0,0 @@
-/**
- * Shared wire types for the crouter web client/server split.
- *
- * The SPA imports the pi payload types it needs from this module — never from
- * broker-protocol internals. The type-only re-exports below keep the web
- * package's shared payload shapes in one place.
- */
-export {};

package/dist/clients/web/web-cmd.d.ts

@@ -1,2 +0,0 @@
-import type { BranchDef } from '../../core/command.js';
-export declare function registerWeb(): BranchDef;

package/dist/clients/web/web-cmd.js

@@ -1,141 +0,0 @@
-// web-cmd.ts — the `crtr surface web` command leaf + registration.
-//
-// Starts the ONE long-running web dev shell (server.ts): a thin reverse proxy in
-// front of crtrd (spec §7.5). It serves the shell SPA, reverse-proxies the crtrd
-// REST API (`/v1/*`) and the attach WS upgrade (`ws://HOST:PORT/node/<id>` →
-// crtrd's `GET /v1/nodes/{id}/attach`) to crtrd's unix socket, plus the SSE
-// change lane (GET /__crtr/events) and web-push endpoints. It hosts NO canvas
-// writer — crtrd is the sole writer; the browser becomes the SAME protocol peer
-// as surface attach. The node is selected by the URL, so there is NO positional
-// node here.
-//
-// Command shape (plan §3.6): the CLI path-walker forbids a flat top-level leaf
-// (`defineRoot.subtrees` is `BranchDef[]`), so `web` is a BRANCH wrapping a
-// single leaf: `crtr surface web serve`.
-import { spawn } from 'node:child_process';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { startWebServer } from './server.js';
-const DEFAULT_PORT = 7878;
-/** Best-effort open of the default browser to `url` (the `--open` flag). Never
- *  throws — a failed open just leaves the user to click the printed URL. */
-function openBrowser(url) {
-    const platform = process.platform;
-    const [cmd, args] = platform === 'darwin'
-        ? ['open', [url]]
-        : platform === 'win32'
-            ? ['cmd', ['/c', 'start', '', url]]
-            : ['xdg-open', [url]];
-    try {
-        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
-        child.on('error', () => {
-            /* no browser opener available — the printed URL is the fallback */
-        });
-        child.unref();
-    }
-    catch {
-        /* ignore */
-    }
-}
-const webServeLeaf = defineLeaf({
-    name: 'serve',
-    description: 'start the crouter web UI server — the browser alternative to a tmux pane for watching the canvas and driving headless nodes',
-    whenToUse: 'you want the crouter web UI in a browser instead of a tmux pane — watching the canvas and driving headless nodes from a page rather than a terminal surface. It is a dev shell that reverse-proxies crtrd (the API and the attach WS); crtrd must be running. Binds 127.0.0.1 by default; pass --host to bind elsewhere, in which case --token is required so the page can authorize. Pass --dev only if you are iterating on the shell itself (Vite HMR) rather than just running it. The node is picked in the browser via the URL, not on the command line; the server runs until ctrl+c.',
-    help: {
-        name: 'web serve',
-        summary: 'start the crouter web UI server — the browser alternative to a tmux pane for watching the canvas and driving headless nodes',
-        params: [
-            {
-                kind: 'flag',
-                name: 'port',
-                type: 'int',
-                required: false,
-                default: DEFAULT_PORT,
-                constraint: `TCP port to bind on 127.0.0.1. Default ${DEFAULT_PORT}.`,
-            },
-            {
-                kind: 'flag',
-                name: 'host',
-                type: 'string',
-                required: false,
-                default: '127.0.0.1',
-                constraint: 'TCP host to bind. Default 127.0.0.1. Non-loopback binds require --token.',
-            },
-            {
-                kind: 'flag',
-                name: 'token',
-                type: 'string',
-                required: false,
-                constraint: 'Bearer token for remote-capable proxy, SSE, and attach relay requests. Required for non-loopback binds.',
-            },
-            {
-                kind: 'flag',
-                name: 'open',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Auto-open the default browser to the served URL after the server starts.',
-            },
-            {
-                kind: 'flag',
-                name: 'dev',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Serve shell assets via a Vite dev server (middleware mode, HMR) instead of the prebuilt dist/web-client/ bundle. The REST proxy, SSE lane, and WS relay are identical in both modes.',
-            },
-        ],
-        output: [],
-        outputKind: 'object',
-        effects: [
-            'Binds a long-running HTTP+WebSocket server on the requested host and port and keeps serving until interrupted (ctrl+c / SIGTERM). Safe to run non-interactively (daemon-like): it prints the URL and serves.',
-            'Serves the shell SPA (static dist/web-client/, or Vite middleware under --dev), reverse-proxies the crtrd REST API (/v1/*) to crtrd\'s unix socket, streams the GET /__crtr/events SSE change lane, and on a browser ws://HOST:<port>/node/<id> connection tunnels the WS upgrade to crtrd\'s GET /v1/nodes/<id>/attach, relaying bytes VERBATIM both directions. Non-loopback binds require a token so the remote route is not an unauthenticated surface.',
-            'This process hosts NO canvas writer: it opens no canvas.db and spawns no bridge subprocess. Every write and every canvas read flows to crtrd (the sole writer) through the proxy and the attach tunnel; crtrd owns attach-implies-revive. crtrd must be running.',
-        ],
-    },
-    run: async (input) => {
-        const port = input['port'] ?? DEFAULT_PORT;
-        const host = input['host'] ?? '127.0.0.1';
-        const tokenRaw = input['token'];
-        const token = tokenRaw !== undefined && tokenRaw !== '' ? tokenRaw : undefined;
-        const open = input['open'] ?? false;
-        const dev = input['dev'] ?? false;
-        const server = await startWebServer({ port, host, token, dev });
-        const nodeUrlShape = `${server.url}/nodes/<id>`;
-        const browserUrl = token !== undefined ? `${server.url}?token=${encodeURIComponent(token)}` : server.url;
-        process.stdout.write(`crtr surface web serving on ${server.url}${dev ? ' (--dev: Vite middleware)' : ''}\n` +
-            `  open a node:  ${nodeUrlShape}\n` +
-            `  api proxy:    ${server.url}/v1/* → crtrd\n` +
-            `  events (SSE): GET  ${server.url}/__crtr/events\n` +
-            `  shell assets: ${dev ? 'Vite middleware (HMR)' : server.clientDir}\n` +
-            `  (ctrl+c to stop)\n`);
-        if (open)
-            openBrowser(browserUrl);
-        // Long-running: resolve only on a shutdown signal, tearing down cleanly.
-        await new Promise((resolveShutdown) => {
-            const shutdown = () => {
-                void server.close().then(() => resolveShutdown());
-            };
-            process.once('SIGINT', shutdown);
-            process.once('SIGTERM', shutdown);
-            process.once('SIGHUP', shutdown);
-        });
-        return;
-    },
-    render: () => '',
-});
-export function registerWeb() {
-    return defineBranch({
-        name: 'web',
-        rootEntry: {
-            concept: 'the crouter web UI server — the browser alternative to a tmux pane for watching the canvas and driving headless nodes',
-            desc: 'serve the crouter web UI for the canvas and headless nodes',
-            useWhen: 'you want the crouter web UI in a browser instead of a tmux pane: watch the canvas and drive headless nodes from a page. Binds 127.0.0.1 by default; a non-loopback bind requires a token so the page can authorize. The node is selected in the browser via the URL, not on the command line.',
-        },
-        help: {
-            name: 'web',
-            summary: 'serve the crouter web UI — the browser alternative to a tmux pane for the canvas and headless nodes',
-            model: 'The branch is a long-running browser surface, an alternative to a tmux pane. `serve` binds a host and port (loopback by default; --token required off-loopback) and runs until interrupted. The node is chosen in the browser via the URL, not on the command line; the server itself only hosts the surface and never spawns an engine.',
-        },
-        children: [webServeLeaf],
-    });
-}

package/dist/commands/__tests__/api-canvas-source.test.d.ts

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

package/dist/commands/__tests__/api-canvas-source.test.js

@@ -1,37 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { ApiCanvasSource } from '../api-client.js';
-const detail = {
-    node_id: 'node-1',
-    name: 'test',
-    kind: 'general',
-    mode: 'base',
-    lifecycle: 'resident',
-    status: 'active',
-    cwd: '/tmp/project',
-    host_kind: 'broker',
-    profile_id: null,
-    parent: null,
-    created: '2026-07-31T00:00:00.000Z',
-    intent: null,
-    waiting_for: null,
-    pi_pid: null,
-    final_report: null,
-    finalized_at: null,
-    description: 'generated-description',
-    icon: '\uf1fc',
-    edges: { parent: null, spawned_by: null, subscribes_to: [], subscribers: [], children: [] },
-    paths: {
-        node_dir: '/tmp/node',
-        context_dir: '/tmp/node/context',
-        reports_dir: '/tmp/node/reports',
-        meta_path: '/tmp/node/meta.json',
-        inbox_path: '/tmp/node/inbox.jsonl',
-        transcript_path: '/tmp/node/transcript.jsonl',
-        view_socket: '/tmp/node/view.sock',
-    },
-};
-test('the API canvas source retains the node icon needed by a reloaded viewer', async () => {
-    const source = new ApiCanvasSource({ getNode: async () => detail });
-    assert.equal((await source.getNode(detail.node_id))?.icon, '\uf1fc');
-});

package/dist/commands/__tests__/canvas-config.test.d.ts

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

package/dist/commands/__tests__/canvas-config.test.js

@@ -1,107 +0,0 @@
-// canvas-config.test.ts — `canvas config list`/`show` (`../canvas-config.ts`)
-// mask every target's token presence/fingerprint from a SINGLE preloaded
-// `SecretsStore`, never re-reading/reparsing `secrets.json` once per target
-// (Minor 1, Phase 3 review 3).
-//
-// Proving "reads secrets.json once, not per target" can't be done by spying —
-// this is a real ESM module (`node:test`'s `mock.method` cannot redefine a
-// non-configurable ESM export; confirmed empirically, not assumed). Instead
-// `secrets.json` is a real named pipe (FIFO) with exactly ONE writer that
-// delivers its payload once and then closes: a SECOND `readFileSync` on that
-// path blocks forever waiting for a writer that will never come. So `list`
-// across N>1 targets only resolves within the timeout if it reads the file
-// exactly once — the old per-target-read code would hang on the second
-// target's read and this test would time out.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { execFileSync, spawn } from 'node:child_process';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Readable } from 'node:stream';
-import { canvasConfigBranch } from '../canvas-config.js';
-import { updateConfig } from '../../core/config.js';
-import { readSecrets } from '../../core/secrets.js';
-import { InputError } from '../../core/io.js';
-function leaf(name) {
-    const found = (canvasConfigBranch.children ?? []).find((c) => c.name === name);
-    if (found === undefined || found.kind !== 'leaf')
-        throw new Error(`no leaf '${name}' under canvas config`);
-    return found;
-}
-let home;
-let realHome;
-before(() => {
-    realHome = process.env['HOME'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-canvas-config-'));
-    process.env['HOME'] = home;
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-});
-test('list masks N targets from ONE secrets.json read — a per-target re-read would hang on the exhausted FIFO', async () => {
-    // Three registered targets, each with a stored token — a per-target
-    // re-read regression would need 3 successful reads of secrets.json.
-    updateConfig('user', (cfg) => {
-        cfg.remoteCanvas.targets['alpha'] = { previewEndpoint: 'https://a.example', relayTokenRef: 'alpha' };
-        cfg.remoteCanvas.targets['beta'] = { previewEndpoint: 'https://b.example', relayTokenRef: 'beta' };
-        cfg.remoteCanvas.targets['gamma'] = { previewEndpoint: 'https://c.example', relayTokenRef: 'gamma' };
-    });
-    const crouterDir = join(home, '.crouter');
-    mkdirSync(crouterDir, { recursive: true });
-    const secretsPath = join(crouterDir, 'secrets.json');
-    execFileSync('mkfifo', [secretsPath]);
-    const payload = JSON.stringify({ relayTokens: { alpha: 'tok-a', beta: 'tok-b', gamma: 'tok-c' } });
-    // A single writer: opens the FIFO, writes the payload once, and exits —
-    // there is no second writer, so a second reader blocks forever.
-    const writer = spawn('sh', ['-c', `printf '%s' '${payload}' > '${secretsPath}'`], { stdio: 'ignore' });
-    try {
-        const result = await Promise.race([
-            leaf('list').run({}),
-            new Promise((_resolve, reject) => setTimeout(() => reject(new Error('list did not resolve — a second secrets.json read is blocking on the exhausted FIFO (per-target re-read regression)')), 2000)),
-        ]);
-        const targets = result['targets'];
-        assert.equal(targets.length, 3);
-        const byName = Object.fromEntries(targets.map((t) => [t['name'], t]));
-        assert.equal(byName['alpha']?.['tokenStored'], true);
-        assert.equal(byName['beta']?.['tokenStored'], true);
-        assert.equal(byName['gamma']?.['tokenStored'], true);
-        assert.notEqual(byName['alpha']?.['fingerprint'], byName['beta']?.['fingerprint']);
-    }
-    finally {
-        writer.kill();
-        // Replace the FIFO with a plain file so later tests in this process (or a
-        // stray writer) don't wedge on it.
-        rmSync(secretsPath, { force: true });
-        writeFileSync(secretsPath, payload);
-    }
-});
-// --- Phase 3 review Major 2: `add --relay-token` must be stdin-only ---
-test('add rejects a literal (non-"-") --relay-token value with a generic error that never echoes the received secret', async () => {
-    const secret = 'some-literal-secret-value';
-    await assert.rejects(() => leaf('add').run({ name: 'literal-reject-test', preview: 'https://example.test', relayToken: secret, cp: undefined }), (err) => {
-        assert.ok(err instanceof InputError, `expected InputError, got ${err}`);
-        const serialized = JSON.stringify({ message: err.message, payload: err.payload });
-        assert.ok(!serialized.includes(secret), 'the thrown error must never interpolate the received relay-token value');
-        return true;
-    });
-});
-test('add with --relay-token - reads the raw token from stdin and stores it', async () => {
-    const realStdin = process.stdin;
-    const fakeStdin = Readable.from([Buffer.from('piped-stdin-token\n')]);
-    fakeStdin.isTTY = false;
-    Object.defineProperty(process, 'stdin', { value: fakeStdin, configurable: true });
-    try {
-        const result = await leaf('add').run({ name: 'stdin-add-test', preview: 'https://example.test', relayToken: '-', cp: undefined });
-        assert.equal(result['tokenStored'], true);
-        const secrets = readSecrets('user');
-        assert.equal(secrets.relayTokens['stdin-add-test'], 'piped-stdin-token');
-    }
-    finally {
-        Object.defineProperty(process, 'stdin', { value: realStdin, configurable: true });
-    }
-});

package/dist/commands/__tests__/node-no-kickoff-flag.test.d.ts

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

package/dist/commands/__tests__/node-no-kickoff-flag.test.js

@@ -1,73 +0,0 @@
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { registerNode } from '../node.js';
-import { parseArgv } from '../../core/command.js';
-import { InputError } from '../../core/io.js';
-// `node new` is now a pure crtrd API client: the real end-to-end idle spawn
-// (broker + session up, zero model turns, follow_up notes IDLE) is exercised
-// against a REAL daemon in the B-1 parity harness and the daemon full tier
-// (src/daemon/api/__tests__/full/api-server.test.ts drives client.createNode +
-// real brokers). What stays worth testing here is the pure CLI-side flag matrix:
-// every mutually-exclusive --no-kickoff guard fires BEFORE any client call, so
-// these run with no daemon.
-const owner = 'no-kickoff-flag-owner';
-let home;
-let previousHome;
-let previousNodeId;
-function nodeNew() {
-    const command = registerNode().children.find((child) => child.name === 'new');
-    assert.ok(command?.kind === 'leaf', 'node new leaf is registered');
-    return command;
-}
-before(() => {
-    previousHome = process.env.CRTR_HOME;
-    previousNodeId = process.env.CRTR_NODE_ID;
-    home = mkdtempSync('/tmp/crtr-nk-flag-');
-    process.env.CRTR_HOME = home;
-    process.env.CRTR_NODE_ID = owner;
-});
-after(() => {
-    if (previousHome === undefined)
-        delete process.env.CRTR_HOME;
-    else
-        process.env.CRTR_HOME = previousHome;
-    if (previousNodeId === undefined)
-        delete process.env.CRTR_NODE_ID;
-    else
-        process.env.CRTR_NODE_ID = previousNodeId;
-    rmSync(home, { recursive: true, force: true });
-});
-test('argv parsing accepts an empty/absent stdin prompt (required relaxed to allow --no-kickoff)', async () => {
-    const leaf = nodeNew();
-    // readStdinRaw() short-circuits to '' only when stdin looks like an
-    // interactive TTY (no pipe) — force that so this exercises "no prompt was
-    // piped" without blocking on the test runner's own (never-closing) stdin.
-    const previousTty = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
-    Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true, writable: true });
-    let result;
-    try {
-        result = await parseArgv(leaf.help.params ?? [], ['--root', '--no-kickoff']);
-    }
-    finally {
-        if (previousTty === undefined)
-            Reflect.deleteProperty(process.stdin, 'isTTY');
-        else
-            Object.defineProperty(process.stdin, 'isTTY', previousTty);
-    }
-    assert.equal(result['prompt'], '', 'no stdin was piped, so the resolved prompt is empty');
-    assert.equal(result['noKickoff'], true);
-    assert.equal(result['root'], true);
-});
-test('--no-kickoff without --root is rejected', async () => {
-    await assert.rejects(() => nodeNew().run({ noKickoff: true }), (error) => error instanceof InputError && error.code === 'no_kickoff_requires_root');
-});
-test('--no-kickoff with a prompt is rejected (mutually exclusive)', async () => {
-    await assert.rejects(() => nodeNew().run({ noKickoff: true, root: true, prompt: 'hello' }), (error) => error instanceof InputError && error.code === 'no_kickoff_with_prompt');
-});
-test('--no-kickoff combined with orchestrator mode is rejected', async () => {
-    await assert.rejects(() => nodeNew().run({ noKickoff: true, root: true, mode: 'orchestrator' }), (error) => error instanceof InputError && error.code === 'no_kickoff_orchestrator_unsupported');
-});
-test('no prompt and no --no-kickoff is still rejected (pre-existing requirement preserved)', async () => {
-    await assert.rejects(() => nodeNew().run({ root: true }), (error) => error instanceof InputError && error.code === 'empty_prompt');
-});

package/dist/commands/__tests__/node-worktree-flag.test.d.ts

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

package/dist/commands/__tests__/node-worktree-flag.test.js

@@ -1,49 +0,0 @@
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { registerNode } from '../node.js';
-import { parseArgv } from '../../core/command.js';
-import { CrtrError } from '../../core/errors.js';
-import { InputError } from '../../core/io.js';
-// `node new` is now a pure crtrd API client: the CLI forwards --worktree's base
-// into the createNode request (`worktree: <base>`), and the SERVER's buildRecipe
-// + spawnChild own forwarding it to worktree creation. That server-side forwarding is exercised end-to-end in
-// the daemon full tier (src/daemon/api/__tests__/full/worktree-parity.test.ts).
-// What stays worth testing HERE is the pure CLI-side validation that fires
-// BEFORE any client call, so these run with no daemon.
-const owner = 'worktree-flag-owner';
-let home;
-let previousHome;
-let previousNodeId;
-function nodeNew() {
-    const command = registerNode().children.find((child) => child.name === 'new');
-    assert.ok(command?.kind === 'leaf', 'node new leaf is registered');
-    return command;
-}
-before(() => {
-    previousHome = process.env.CRTR_HOME;
-    previousNodeId = process.env.CRTR_NODE_ID;
-    home = mkdtempSync(join(tmpdir(), 'crtr-node-worktree-flag-'));
-    process.env.CRTR_HOME = home;
-    process.env.CRTR_NODE_ID = owner;
-});
-after(() => {
-    if (previousHome === undefined)
-        delete process.env.CRTR_HOME;
-    else
-        process.env.CRTR_HOME = previousHome;
-    if (previousNodeId === undefined)
-        delete process.env.CRTR_NODE_ID;
-    else
-        process.env.CRTR_NODE_ID = previousNodeId;
-    rmSync(home, { recursive: true, force: true });
-});
-test('bare --worktree is rejected by argv parsing before node new can spawn', async () => {
-    const leaf = nodeNew();
-    await assert.rejects(() => parseArgv(leaf.help.params ?? [], ['prompt', '--worktree']), (error) => error instanceof CrtrError && error.code === 'missing_parameter');
-});
-test('--worktree= is rejected by node new before spawn', async () => {
-    await assert.rejects(() => nodeNew().run({ prompt: 'prompt', worktree: '' }), (error) => error instanceof InputError && error.code === 'worktree_base_required');
-});

package/dist/commands/__tests__/search-contents.test.d.ts

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