@north-light/crouter 0.3.161 → 0.3.163

package/dist/daemon/api/__tests__/full/b10-attach-modelauth.test.js

@@ -34,7 +34,8 @@ import assert from 'node:assert/strict';
 import { existsSync, readFileSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { setAuthCredential } from '../../../../core/auth-file.js';
+import { readAuthCredentials, setAuthCredential } from '../../../../core/auth-file.js';
+import { readSubscriptionPool, writeSubscriptionPool } from '../../../../core/subscription-state.js';
 import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
 import { createAttachKit } from '../../../../core/__tests__/helpers/broker-clients.js';
 import { CrtrClient } from '../../../../api/index.js';
@@ -218,3 +219,124 @@ test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enter
         rmSync(apiDir, { recursive: true, force: true });
     }
 });
+// ---------------------------------------------------------------------------
+// Credential truth/removal — GET exposes only connection state and DELETE
+// clears exactly its provider's durable store.
+// ---------------------------------------------------------------------------
+test('B2-modelauth-status: list is sanitized and delete clears only the selected provider', async () => {
+    const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
+    const apiDir = mkdtempSync(join(tmpdir(), 'crtr-b10-status-'));
+    process.env['PI_CODING_AGENT_DIR'] = apiDir;
+    const expires = 1_900_000_000_000;
+    const cooldown = 1_900_000_100_000;
+    try {
+        await writeSubscriptionPool('anthropic', [
+            {
+                label: 'Claude One',
+                refresh: 'anthropic-refresh-secret',
+                access: 'anthropic-access-secret',
+                expires,
+                rateLimitedUntil: cooldown,
+                lastAttemptAt: 0,
+                lastRateLimitedAt: 0,
+                authFailure: 'invalid_grant',
+                accountId: 'anthropic-account-id',
+            },
+            {
+                label: 'Claude Two',
+                refresh: 'second-refresh-secret',
+                access: 'second-access-secret',
+                expires,
+                rateLimitedUntil: 0,
+                lastAttemptAt: 0,
+                lastRateLimitedAt: 0,
+            },
+        ]);
+        await writeSubscriptionPool('openai-codex', [
+            {
+                label: 'ChatGPT',
+                refresh: 'codex-refresh-secret',
+                access: 'codex-access-secret',
+                expires,
+                rateLimitedUntil: 0,
+                lastAttemptAt: 0,
+                lastRateLimitedAt: 0,
+                accountId: 'codex-account-id',
+            },
+        ]);
+        await setAuthCredential('github-copilot', {
+            type: 'oauth',
+            access: 'copilot-access-secret',
+            refresh: 'copilot-refresh-secret',
+            expires,
+        }, join(apiDir, 'auth.json'));
+        // A managed provider may also have a hand-configured API key. It remains
+        // intentionally absent from status, but DELETE must remove it too.
+        await setAuthCredential('anthropic', { type: 'api_key', key: 'anthropic-api-key-secret' }, join(apiDir, 'auth.json'));
+        const status = await client.listModelAuth();
+        assert.deepEqual(status.providers, [
+            {
+                provider: 'anthropic',
+                managed: true,
+                configured: true,
+                accounts: [
+                    {
+                        label: 'Claude One',
+                        expires_at: new Date(expires).toISOString(),
+                        rate_limited_until: new Date(cooldown).toISOString(),
+                        auth_failure: 'invalid_grant',
+                        account_id: 'anthropic-account-id',
+                    },
+                    {
+                        label: 'Claude Two',
+                        expires_at: new Date(expires).toISOString(),
+                        rate_limited_until: new Date(0).toISOString(),
+                    },
+                ],
+            },
+            {
+                provider: 'openai-codex',
+                managed: true,
+                configured: true,
+                accounts: [
+                    {
+                        label: 'ChatGPT',
+                        expires_at: new Date(expires).toISOString(),
+                        rate_limited_until: new Date(0).toISOString(),
+                        account_id: 'codex-account-id',
+                    },
+                ],
+            },
+            { provider: 'github-copilot', managed: false, configured: true, kind: 'oauth' },
+        ]);
+        const wire = JSON.stringify(status);
+        for (const secret of [
+            'anthropic-refresh-secret',
+            'anthropic-access-secret',
+            'second-refresh-secret',
+            'second-access-secret',
+            'codex-refresh-secret',
+            'codex-access-secret',
+            'copilot-refresh-secret',
+            'copilot-access-secret',
+            'anthropic-api-key-secret',
+        ]) {
+            assert.ok(!wire.includes(secret), `status never exposes ${secret}`);
+        }
+        const removedManaged = await client.removeCredential('anthropic');
+        assert.deepEqual(removedManaged, { provider: 'anthropic', removed_accounts: 3 });
+        assert.deepEqual(readSubscriptionPool('anthropic'), [], 'selected managed pool is empty');
+        assert.ok(!Object.hasOwn(await readAuthCredentials(join(apiDir, 'auth.json')), 'anthropic'), 'managed API key is removed');
+        assert.equal(readSubscriptionPool('openai-codex').length, 1, 'other managed pool is unchanged');
+        const removedOauth = await client.removeCredential('github-copilot');
+        assert.deepEqual(removedOauth, { provider: 'github-copilot', removed_accounts: 1 });
+        assert.deepEqual((await client.listModelAuth()).providers.map((provider) => provider.provider), ['anthropic', 'openai-codex'], 'deleted auth.json credential no longer appears in status');
+    }
+    finally {
+        if (savedPiDir === undefined)
+            delete process.env['PI_CODING_AGENT_DIR'];
+        else
+            process.env['PI_CODING_AGENT_DIR'] = savedPiDir;
+        rmSync(apiDir, { recursive: true, force: true });
+    }
+});

package/dist/daemon/api/handlers/modelauth.js

@@ -8,12 +8,14 @@
 // fans `reload_auth` to live brokers — a write here is picked up by that watcher
 // (do NOT re-implement the fan).
 //
+//   GET /v1/model-auth             sanitized credential presence
 //   PUT /v1/model-auth/:provider   install/rotate a credential (idempotent)
+//   DELETE /v1/model-auth/:provider remove all credentials for one provider
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { setAuthCredential } from '../../../core/auth-file.js';
+import { deleteAuthCredential, readAuthCredentials, setAuthCredential } from '../../../core/auth-file.js';
 import { ApiError } from '../../../api/index.js';
-import { ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID, commitManagedLogin, readSubscriptionPool, } from '../../../core/subscription-state.js';
+import { ANTHROPIC_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID, commitManagedLogin, readSubscriptionPool, removeAllManagedAccounts, } from '../../../core/subscription-state.js';
 /** Resolve the shared pi credentials file, matching the daemon's auth.json
  *  mtime watcher exactly (`PI_CODING_AGENT_DIR` env, else `~/.pi/agent`) so a
  *  write here is the file that watcher fans a `reload_auth` for. */
@@ -43,6 +45,37 @@ function requireField(kind, field, value) {
     }
     return value;
 }
+function toManagedAccountStatus(account) {
+    return {
+        label: account.label,
+        expires_at: new Date(account.expires).toISOString(),
+        rate_limited_until: new Date(account.rateLimitedUntil).toISOString(),
+        ...(account.authFailure ? { auth_failure: account.authFailure } : {}),
+        ...(account.accountId ? { account_id: account.accountId } : {}),
+    };
+}
+function managedStatus(provider) {
+    const accounts = readSubscriptionPool(provider).map(toManagedAccountStatus);
+    return { provider, managed: true, configured: accounts.length > 0, accounts };
+}
+/** `GET /v1/model-auth` — credential truth projected without tokens, keys, or
+ * other auth-file material. Managed providers always reflect their complete
+ * pool rows, while non-managed presence reflects supported auth.json kinds. */
+async function handleList() {
+    const credentials = await readAuthCredentials(authPath());
+    const providers = [
+        managedStatus(ANTHROPIC_PROVIDER_ID),
+        managedStatus(OPENAI_CODEX_PROVIDER_ID),
+    ];
+    for (const [provider, credential] of Object.entries(credentials)) {
+        if (isManagedProvider(provider))
+            continue;
+        if (credential.type !== 'api_key' && credential.type !== 'oauth')
+            continue;
+        providers.push({ provider, managed: false, configured: true, kind: credential.type });
+    }
+    return { status: 200, body: { providers } };
+}
 /** `PUT /v1/model-auth/:provider` — idempotent upsert/rotate keyed by provider
  *  (and `account_id` for a managed account). */
 async function handleInstall(ctx) {
@@ -111,6 +144,22 @@ async function handleInstall(ctx) {
             throw new ApiError(400, 'invalid_request', `unknown credential kind: ${String(req.kind)}`);
     }
 }
+/** `DELETE /v1/model-auth/:provider` — remove all durable user credentials for
+ * one provider. Managed OAuth accounts are cleared through their pool lock and
+ * any managed-provider API key through the auth.json lock; other providers use
+ * the auth.json owner alone. */
+async function handleDelete(ctx) {
+    const provider = ctx.params['provider'];
+    if (isManagedProvider(provider)) {
+        const removedAccounts = await removeAllManagedAccounts(provider);
+        const removedApiKey = await deleteAuthCredential(provider, authPath());
+        return { status: 200, body: { provider, removed_accounts: removedAccounts + (removedApiKey ? 1 : 0) } };
+    }
+    const removedAccounts = await deleteAuthCredential(provider, authPath()) ? 1 : 0;
+    return { status: 200, body: { provider, removed_accounts: removedAccounts } };
+}
 export const modelAuthRoutes = [
+    { method: 'GET', pattern: '/v1/model-auth', handler: handleList },
     { method: 'PUT', pattern: '/v1/model-auth/:provider', handler: handleInstall },
+    { method: 'DELETE', pattern: '/v1/model-auth/:provider', handler: handleDelete },
 ];

package/dist/daemon/api/handlers/nodes.js

@@ -365,6 +365,7 @@ function handleDemote(ctx) {
         ...(meta.launch?.modelProviderPinned !== undefined
             ? { modelProviderPinned: meta.launch.modelProviderPinned }
             : {}),
+        ...(meta.launch?.modelIntent !== undefined ? { modelIntent: meta.launch.modelIntent } : {}),
         cwd: meta.cwd,
         profileId: meta.profile_id ?? null,
     });
@@ -485,6 +486,7 @@ async function handleConfig(ctx) {
             hasManager: meta.parent !== null,
             ...(meta.model_override != null ? { model: meta.model_override } : {}),
             ...(meta.launch?.modelProviderPinned !== undefined ? { modelProviderPinned: meta.launch.modelProviderPinned } : {}),
+            ...(meta.launch?.modelIntent !== undefined ? { modelIntent: meta.launch.modelIntent } : {}),
             cwd: meta.cwd,
             profileId: meta.profile_id ?? null,
         });

package/dist/pi-extensions/__tests__/canvas-tool-guide.test.d.ts

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

package/dist/pi-extensions/__tests__/canvas-tool-guide.test.js

@@ -0,0 +1,96 @@
+// Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-tool-guide.test.ts
+//
+// Regression: canvas brokers must load and inject the root crtr guide themselves;
+// optional pi packages are not part of the canvas runtime contract.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { CANVAS_EXTENSIONS, CANVAS_TOOL_GUIDE_PATH } from '../../core/runtime/canvas-extensions.js';
+import registerCanvasToolGuide from '../canvas-tool-guide.js';
+function fakePi() {
+    return {
+        on(event, handler) {
+            if (event === 'before_agent_start')
+                this.beforeAgentStart = handler;
+            if (event === 'session_start')
+                this.sessionStart = handler;
+        },
+    };
+}
+test('canvas nodes load the cwd-specific root guide, share its boot cache, and never capture during a turn', async () => {
+    assert.ok(CANVAS_EXTENSIONS.includes(CANVAS_TOOL_GUIDE_PATH), 'the guide is a mandatory canvas extension');
+    const root = mkdtempSync(join(tmpdir(), 'crtr-tool-guide-'));
+    const bin = join(root, 'bin');
+    const cwd = join(root, 'configured-project');
+    const countFile = join(root, 'capture-count');
+    const capturedCwdFile = join(root, 'capture-cwd');
+    const previous = {
+        cwd: process.cwd(),
+        home: process.env['HOME'],
+        nodeId: process.env['CRTR_NODE_ID'],
+        path: process.env['PATH'],
+    };
+    try {
+        mkdirSync(bin);
+        mkdirSync(cwd);
+        const command = join(bin, 'crtr');
+        writeFileSync(command, `#!/bin/sh
+count=0
+if [ -f "$CAPTURE_COUNT" ]; then count=$(cat "$CAPTURE_COUNT"); fi
+printf '%s' "$((count + 1))" > "$CAPTURE_COUNT"
+printf '%s' "$PWD" > "$CAPTURE_CWD"
+printf '%s\\n' 'configured root guide'
+`);
+        chmodSync(command, 0o755);
+        process.chdir(cwd);
+        process.env['HOME'] = root;
+        process.env['CRTR_NODE_ID'] = 'canvas-tool-guide-test';
+        process.env['PATH'] = `${bin}${delimiter}${previous.path ?? ''}`;
+        process.env['CAPTURE_COUNT'] = countFile;
+        process.env['CAPTURE_CWD'] = capturedCwdFile;
+        const first = fakePi();
+        registerCanvasToolGuide(first);
+        const firstSessionStart = first.sessionStart;
+        assert.ok(firstSessionStart, 'session-start capture is registered');
+        await firstSessionStart();
+        const second = fakePi();
+        registerCanvasToolGuide(second);
+        const secondSessionStart = second.sessionStart;
+        assert.ok(secondSessionStart, 'session-start capture is registered for every broker');
+        await secondSessionStart();
+        assert.equal(readFileSync(countFile, 'utf8'), '1', 'a sibling broker uses the 15-second disk cache');
+        assert.equal(readFileSync(capturedCwdFile, 'utf8'), realpathSync(cwd), 'root help discovers commands from the node cwd');
+        const beforeAgentStart = second.beforeAgentStart;
+        assert.ok(beforeAgentStart, 'turn-time guide injection is registered');
+        const prompt = 'Available tools\n\nGuidelines:\nUse the available tools.';
+        assert.equal(beforeAgentStart({ systemPrompt: prompt })?.systemPrompt, 'Available tools\n\n<crtr-tool-guide>\nconfigured root guide\n</crtr-tool-guide>\n\nGuidelines:\nUse the available tools.', 'the captured guide sits in the tool-selection frame');
+        rmSync(join(root, '.crouter'), { recursive: true, force: true });
+        const unbooted = fakePi();
+        registerCanvasToolGuide(unbooted);
+        const unbootedBeforeAgentStart = unbooted.beforeAgentStart;
+        assert.ok(unbootedBeforeAgentStart, 'turn-time guide injection is registered before boot capture');
+        assert.equal(unbootedBeforeAgentStart({ systemPrompt: prompt }), undefined, 'a node without a boot capture starts without a guide');
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        assert.equal(readFileSync(countFile, 'utf8'), '1', 'a turn never starts a root-help subprocess');
+    }
+    finally {
+        process.chdir(previous.cwd);
+        if (previous.home === undefined)
+            delete process.env['HOME'];
+        else
+            process.env['HOME'] = previous.home;
+        if (previous.nodeId === undefined)
+            delete process.env['CRTR_NODE_ID'];
+        else
+            process.env['CRTR_NODE_ID'] = previous.nodeId;
+        if (previous.path === undefined)
+            delete process.env['PATH'];
+        else
+            process.env['PATH'] = previous.path;
+        delete process.env['CAPTURE_COUNT'];
+        delete process.env['CAPTURE_CWD'];
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/pi-extensions/canvas-doc-substrate.js

@@ -12,16 +12,15 @@
 //      into `event.systemPrompt`, right after pi's native "Available tools" list
 //      (before the `\n\nGuidelines:` anchor), so the substrate's standing
 //      directives sit in the tool-selection frame the agent reads while choosing
-//      a capability — mirroring the personal crouter-help.ts anchor logic. Falls
-//      back to appending when the anchor is absent. (The `<memory kind="knowledge">`
+//      a capability. Falls back to appending when the anchor is absent. (The `<memory kind="knowledge">`
 //      catalog rides the bearings message instead — see core/substrate/render.ts.)
 //
 //   2. tool_result (gated on `read`) — the ON-READ half. For each non-error
-//      `read`, surfaces the substrate docs that should appear alongside the file
-//      (positional `.crouter/memory/` ancestors + `applies-to` globs) at their
-//      file-read-visibility rung, prepended as a `<auto-loaded-context>` block
-//      before the file contents. A per-session realpath set dedups so the same
-//      doc is not re-injected on repeat reads.
+//      `read`, evaluates explicit `applies-to` globs (plus `read-when` metadata)
+//      across the resolved corpus and any project stores enclosing the read
+//      file. Matches render at their file-read rung in `<auto-loaded-context>`
+//      before the file contents. A transcript-scoped realpath set deduplicates
+//      repeated reads and resumed broker processes.
 //
 // Both handler bodies are wrapped in try/catch and degrade to INERT on error —
 // a substrate bug must never brick node boot or break a `read`, only quietly
@@ -42,7 +41,7 @@ import { loadInjectedDocs, saveInjectedDocs } from '../core/substrate/injected-s
 /** The stable seam that closes pi's native "Available tools" list. We splice the
  *  substrate's boot sections right before it — the agent decides which capability
  *  to reach for while reading the tools, so memory docs/preferences must sit
- *  there, not far below. Mirrors crouter-help.ts. Falls back to appending if absent. */
+ *  there, not far below. Falls back to appending if absent. */
 const TOOLS_ANCHOR = '\n\nGuidelines:';
 const AUTO_CONTEXT_RE = /<auto-loaded-context(?:\s[^>]*)?>\n([\s\S]*?)\n<\/auto-loaded-context>/;
 function mergeAutoLoadedContext(injected, content) {

package/dist/pi-extensions/canvas-tool-guide.d.ts

@@ -0,0 +1,14 @@
+declare function injectToolGuide(systemPrompt: string, helpText: string): string;
+interface BeforeAgentStartEventLike {
+    systemPrompt: string;
+}
+interface PiLike {
+    on(event: 'session_start', handler: () => void | Promise<void>): void;
+    on(event: 'before_agent_start', handler: (event: BeforeAgentStartEventLike) => {
+        systemPrompt: string;
+    } | void): void;
+}
+/** Register the root crtr tool-guide injection for a canvas node. */
+export declare function registerCanvasToolGuide(pi: PiLike): void;
+export { injectToolGuide };
+export default registerCanvasToolGuide;

package/dist/pi-extensions/canvas-tool-guide.js

@@ -0,0 +1,74 @@
+// canvas-tool-guide.ts — injects the root crtr CLI guide into every canvas node.
+//
+// Capturing `crtr -h` builds the full configured command tree, including commands
+// discovered from the node's cwd. It runs only at session start; before_agent_start
+// injects the last successful capture without starting work or waiting.
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+const TTL_MS = 15_000;
+const TOOLS_ANCHOR = '\n\nGuidelines:';
+function helpCacheFile(cwd) {
+    const hash = createHash('sha1').update(cwd).digest('hex').slice(0, 16);
+    return join(homedir(), '.crouter', 'cache', `crtr-tool-guide-${hash}.json`);
+}
+function injectToolGuide(systemPrompt, helpText) {
+    const block = `<crtr-tool-guide>\n${helpText}\n</crtr-tool-guide>`;
+    const anchor = systemPrompt.indexOf(TOOLS_ANCHOR);
+    if (anchor === -1)
+        return `${systemPrompt}\n\n${block}`;
+    return `${systemPrompt.slice(0, anchor)}\n\n${block}${systemPrompt.slice(anchor)}`;
+}
+/** Register the root crtr tool-guide injection for a canvas node. */
+export function registerCanvasToolGuide(pi) {
+    const nodeId = process.env['CRTR_NODE_ID'];
+    if (nodeId === undefined || nodeId.trim() === '')
+        return;
+    let helpText = '';
+    let capturedAt = 0;
+    async function refresh() {
+        if (helpText !== '' && Date.now() - capturedAt < TTL_MS)
+            return;
+        const file = helpCacheFile(process.cwd());
+        try {
+            const cached = JSON.parse(readFileSync(file, 'utf8'));
+            if (typeof cached.text === 'string' && cached.text !== '' && typeof cached.at === 'number' && Date.now() - cached.at < TTL_MS) {
+                helpText = cached.text;
+                capturedAt = cached.at;
+                return;
+            }
+        }
+        catch {
+            // A missing or invalid cache is refreshed below.
+        }
+        try {
+            const { stdout } = await run('crtr', ['-h'], { timeout: 10_000 });
+            helpText = stdout.trim();
+            capturedAt = Date.now();
+            try {
+                mkdirSync(dirname(file), { recursive: true });
+                writeFileSync(file, JSON.stringify({ text: helpText, at: capturedAt }), 'utf8');
+            }
+            catch {
+                // The guide remains available in this broker even when its cache cannot persist.
+            }
+        }
+        catch {
+            // Keep the last successful guide and never delay a turn for a failed capture.
+        }
+    }
+    // Node startup is the only point a capture may wait. Warm spares pay it before
+    // a user claims them; resumed nodes refresh before their next turn.
+    pi.on('session_start', refresh);
+    pi.on('before_agent_start', (event) => {
+        if (helpText === '')
+            return;
+        return { systemPrompt: injectToolGuide(event.systemPrompt, helpText) };
+    });
+}
+export { injectToolGuide };
+export default registerCanvasToolGuide;

package/dist/types.d.ts

@@ -99,6 +99,19 @@ export interface ModelLaddersConfig {
     anthropic: Record<ModelStrength, string>;
     openai: Record<ModelStrength, string>;
 }
+/** A declared provider/model route. Route ids are the keys of `modelRoutes` so
+ * scopes can override one route without restating the registry. */
+export interface ModelRouteConfig {
+    family: string;
+    credentialSource: string;
+    providerId: string;
+    models: Partial<Record<ModelStrength, string>>;
+}
+export interface ModelRoutingConfig {
+    credentialSourceOrder?: string[];
+    familyOrder?: string[];
+    strengthFallback?: ModelStrength[];
+}
 /** Launch metadata for one kind (a top-level kind like `developer`, or a full
  *  sub-kind string like `plan/reviewers/security`) — the settings-file
  *  replacement for per-kind persona frontmatter. `model`/`tools`/`extensions`
@@ -159,6 +172,10 @@ export interface ScopeConfig {
     fold_finished_tools: boolean;
     keybindings: KeybindingOverrides;
     modelLadders: ModelLaddersConfig;
+    /** Declarative provider/model routes. Absent uses the synthesized ladder registry. */
+    modelRoutes?: Record<string, ModelRouteConfig>;
+    /** Ordering overrides for declared model routes. */
+    modelRouting?: ModelRoutingConfig;
     /** The kind registry (spec §1.5): kind existence + launch knobs, keyed by
      *  full kind string (top-level e.g. `developer`, or sub-kind e.g.
      *  `plan/reviewers/security`). Builtins ship a default registry via