@north-light/crouter 0.3.172 → 0.3.174

package/dist/core/runtime/broker/inbox.d.ts

@@ -0,0 +1,22 @@
+import type { BrokerReportNodeDTO } from '../../../api/dto/broker-ops.js';
+import type { OperationId } from '../../events/types.js';
+export type BrokerInboxEntryId = string & {
+    readonly __brokerInboxEntryId: unique symbol;
+};
+export interface BrokerInboxEntry {
+    entry_id: BrokerInboxEntryId;
+    operation_id: OperationId;
+    ts: string;
+    from: string | null;
+    tier: 'critical' | 'urgent' | 'normal' | 'deferred';
+    kind: 'update' | 'urgent' | 'final' | 'message' | 'completed';
+    ref?: string;
+    label: string;
+    data?: Record<string, unknown>;
+}
+export declare function readBrokerCursor(nodeId: string): BrokerInboxEntryId | undefined;
+export declare function readBrokerInboxSince(nodeId: string, cursor?: string): BrokerInboxEntry[];
+export declare function readBrokerInboxRange(nodeId: string, after: string | undefined, through: string): BrokerInboxEntry[];
+export declare function readBrokerCanceledEntryIds(nodeId: string): Set<BrokerInboxEntryId>;
+/** Render the existing inbox digest wording with daemon-projected report existence. */
+export declare function coalesceBrokerInbox(entries: readonly BrokerInboxEntry[], reportNodes: ReadonlyMap<string, BrokerReportNodeDTO>): string;

package/dist/core/runtime/broker/inbox.js

@@ -0,0 +1,167 @@
+// Broker-local inbox access and rendering. The daemon owns feed delivery; a
+// broker only reads its own files and uses daemon-projected report senders.
+import { existsSync, readFileSync } from 'node:fs';
+import { inboxPath, nodeDir } from '../../canvas/paths.js';
+const ENTRY_ID = /^(?!0{32}$)[0-9a-f]{32}$/;
+const BODY_MAX_LINES = 12;
+const BODY_MAX_CHARS = 1000;
+const INLINE_REPORT_MAX_CHARS = 1000;
+function entryId(value) {
+    if (typeof value !== 'string' || !ENTRY_ID.test(value))
+        throw new TypeError('entry_id must be 32 lowercase non-zero hexadecimal characters');
+    return value;
+}
+function readPhysicalInbox(nodeId) {
+    const path = inboxPath(nodeId);
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, 'utf8');
+    if (raw === '')
+        return [];
+    const lines = raw.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    if (lines.some((line) => line.trim() === ''))
+        throw new Error('inbox contains a blank physical line');
+    const entries = lines.map((line) => {
+        const parsed = JSON.parse(line);
+        parsed.entry_id = entryId(parsed.entry_id);
+        return parsed;
+    });
+    const seen = new Set();
+    for (const entry of entries) {
+        if (seen.has(entry.entry_id))
+            throw new Error(`duplicate inbox entry_id: ${entry.entry_id}`);
+        seen.add(entry.entry_id);
+    }
+    return entries;
+}
+function cursorPath(nodeId) {
+    return `${inboxPath(nodeId)}.cursor`;
+}
+export function readBrokerCursor(nodeId) {
+    const path = cursorPath(nodeId);
+    if (!existsSync(path))
+        return undefined;
+    const raw = readFileSync(path, 'utf8').trim();
+    return raw === '' ? undefined : entryId(raw);
+}
+export function readBrokerInboxSince(nodeId, cursor) {
+    const entries = readPhysicalInbox(nodeId);
+    if (cursor === undefined)
+        return entries;
+    const index = entries.findIndex((entry) => entry.entry_id === entryId(cursor));
+    if (index < 0)
+        throw new Error(`inbox cursor entry_id not found: ${entryId(cursor)}`);
+    return entries.slice(index + 1);
+}
+export function readBrokerInboxRange(nodeId, after, through) {
+    const entries = readPhysicalInbox(nodeId);
+    const throughId = entryId(through);
+    const throughIndex = entries.findIndex((entry) => entry.entry_id === throughId);
+    if (throughIndex < 0)
+        throw new Error(`inbox range through entry_id not found: ${throughId}`);
+    if (after === undefined)
+        return entries.slice(0, throughIndex + 1);
+    const afterId = entryId(after);
+    const afterIndex = entries.findIndex((entry) => entry.entry_id === afterId);
+    if (afterIndex < 0)
+        throw new Error(`inbox range after entry_id not found: ${afterId}`);
+    if (afterIndex >= throughIndex)
+        throw new Error(`inbox range is reversed: ${afterId} through ${throughId}`);
+    return entries.slice(afterIndex + 1, throughIndex + 1);
+}
+export function readBrokerCanceledEntryIds(nodeId) {
+    const path = `${inboxPath(nodeId)}.canceled`;
+    if (!existsSync(path))
+        return new Set();
+    const out = new Set();
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const value = line.trim();
+        if (value !== '')
+            out.add(entryId(value));
+    }
+    return out;
+}
+function inlineBody(entry) {
+    const body = typeof entry.data?.['body'] === 'string' ? String(entry.data['body']).trim() : '';
+    return body === '' || body === entry.label ? '' : body;
+}
+function clipBody(body) {
+    let text = body;
+    let clipped = false;
+    const lines = text.split('\n');
+    if (lines.length > BODY_MAX_LINES) {
+        text = lines.slice(0, BODY_MAX_LINES).join('\n');
+        clipped = true;
+    }
+    if (text.length > BODY_MAX_CHARS) {
+        text = text.slice(0, BODY_MAX_CHARS);
+        clipped = true;
+    }
+    return { text: text.trimEnd(), clipped };
+}
+function inlineReport(entry, reportNodes) {
+    if (entry.ref === undefined || entry.ref.startsWith('/'))
+        return null;
+    const separator = entry.ref.indexOf(':');
+    if (separator <= 0)
+        return null;
+    const nodeId = entry.ref.slice(0, separator);
+    const relpath = entry.ref.slice(separator + 1);
+    if (!reportNodes.has(nodeId) || !relpath.startsWith('reports/') || relpath.includes('..') || relpath.startsWith('/'))
+        return null;
+    const path = `${nodeDir(nodeId)}/${relpath}`;
+    try {
+        const body = readFileSync(path, 'utf8');
+        return body.length >= INLINE_REPORT_MAX_CHARS ? null : { body, path };
+    }
+    catch {
+        return null;
+    }
+}
+function renderEntry(entry, reportNodes) {
+    const report = inlineReport(entry, reportNodes);
+    if (report !== null) {
+        const indented = report.body.trimEnd().split('\n').map((line) => `    ${line}`).join('\n');
+        return { text: `  [${entry.kind}]\n${indented}\n    (report: ${report.path})`, hasCanonicalRef: false };
+    }
+    const body = inlineBody(entry);
+    if (body === '') {
+        const hasCanonicalRef = entry.ref !== undefined && !entry.ref.startsWith('/');
+        return { text: entry.ref === undefined ? `  [${entry.kind}] ${entry.label}` : `  [${entry.kind}] ${entry.label}  (ref: ${entry.ref})`, hasCanonicalRef };
+    }
+    const { text, clipped } = clipBody(body);
+    const indented = text.split('\n').map((line) => `    ${line}`).join('\n');
+    const more = entry.ref !== undefined ? `\n    … (full body: ${entry.ref})` : clipped ? '\n    … (body clipped)' : '';
+    return { text: `  [${entry.kind}]\n${indented}${more}`, hasCanonicalRef: false };
+}
+/** Render the existing inbox digest wording with daemon-projected report existence. */
+export function coalesceBrokerInbox(entries, reportNodes) {
+    if (entries.length === 0)
+        return '(inbox empty)';
+    const groups = new Map();
+    for (const entry of entries) {
+        const key = entry.from ?? 'system';
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(entry);
+    }
+    let hasCanonicalRef = false;
+    const sections = [];
+    for (const [sender, items] of groups) {
+        if (sender === 'human') {
+            for (const entry of items) {
+                const body = inlineBody(entry);
+                sections.push(body === '' ? entry.label : body);
+            }
+            continue;
+        }
+        const lines = items.map((entry) => renderEntry(entry, reportNodes));
+        if (lines.some((line) => line.hasCanonicalRef))
+            hasCanonicalRef = true;
+        sections.push(`From ${sender} — ${items.length} update${items.length === 1 ? '' : 's'}:\n${lines.map((line) => line.text).join('\n')}`);
+    }
+    const digest = sections.join('\n\n');
+    return hasCanonicalRef ? `${digest}\n\nDereference a ref with \`crtr canvas history read <ref>\`.` : digest;
+}

package/dist/core/runtime/broker/passive.d.ts

@@ -0,0 +1,16 @@
+/** Structural copy of an InboxEntry used by broker presentation only. Keeping
+ * this type here avoids importing the feed implementation into the broker. */
+export interface BrokerPassiveEntry {
+    entry_id: string;
+    operation_id: string;
+    ts: string;
+    from: string | null;
+    tier: string;
+    kind: string;
+    ref?: string;
+    label: string;
+    data?: Record<string, unknown>;
+}
+/** Read and clear the passive accumulator, preserving the rename-before-read
+ * race boundary used by the daemon's feed writer. */
+export declare function drainBrokerPassive(nodeId: string): BrokerPassiveEntry[];

package/dist/core/runtime/broker/passive.js

@@ -0,0 +1,44 @@
+// Broker-local passive feed access. This deliberately avoids the canvas/feed
+// barrels: those are daemon-side modules and their import graph reaches the
+// canvas database. A broker only needs the node-owned JSONL accumulator.
+import { existsSync, readFileSync, renameSync, rmSync, } from 'node:fs';
+import { passivePath } from '../../canvas/paths.js';
+function parseEntries(text) {
+    const entries = [];
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        try {
+            entries.push(JSON.parse(line));
+        }
+        catch {
+            // Preserve the feed's tolerant per-line corruption behavior.
+        }
+    }
+    return entries;
+}
+/** Read and clear the passive accumulator, preserving the rename-before-read
+ * race boundary used by the daemon's feed writer. */
+export function drainBrokerPassive(nodeId) {
+    const path = passivePath(nodeId);
+    if (!existsSync(path))
+        return [];
+    const snapshot = `${path}.draining`;
+    try {
+        renameSync(path, snapshot);
+    }
+    catch {
+        return [];
+    }
+    let entries = [];
+    try {
+        entries = parseEntries(readFileSync(snapshot, 'utf8'));
+    }
+    finally {
+        try {
+            rmSync(snapshot, { force: true });
+        }
+        catch { /* best effort */ }
+    }
+    return entries;
+}

package/dist/core/runtime/broker/read-ops.d.ts

@@ -0,0 +1,23 @@
+import { type CreateAgentSessionResult } from '@earendil-works/pi-coding-agent';
+import { type DeterministicCommandExpansion } from '../command-expansion.js';
+import { SessionListCache } from '../session-list-cache.js';
+import { type GetSettingsData, type GetTreeData, type ListMemoryRefsData, type ListModelsData, type ListScopedModelsData, type ListSessionsData, type RefMeta } from '../broker-protocol.js';
+export type BrokerSession = CreateAgentSessionResult['session'];
+export type CommandDisclosure = {
+    name: string;
+    description: string;
+    source: string;
+    template?: string;
+    expansion?: DeterministicCommandExpansion;
+};
+export declare const modelKey: (model: {
+    provider: string;
+    id: string;
+}) => string;
+export declare function buildCommandList(session: BrokerSession): CommandDisclosure[];
+export declare function buildListMemoryRefsData(id: string, refs: RefMeta[], engineLeadingCommandNames: string[]): ListMemoryRefsData;
+export declare function buildListModelsData(id: string, session: BrokerSession): ListModelsData;
+export declare function buildScopedModelsData(id: string, session: BrokerSession): ListScopedModelsData;
+export declare function buildGetTreeData(id: string, session: BrokerSession, reviewCompanion: boolean): GetTreeData;
+export declare function buildSettingsData(id: string, session: BrokerSession): GetSettingsData;
+export declare function buildSessionsData(id: string, scope: 'cwd' | 'all', session: BrokerSession, cache: SessionListCache): Promise<ListSessionsData>;

package/dist/core/runtime/broker/read-ops.js

@@ -0,0 +1,150 @@
+import { ModelRegistry } from '@earendil-works/pi-coding-agent';
+import { boundaryRootedTree } from '../session-visibility.js';
+import { isUnknownModel } from '../model-selection.js';
+import { BUILTIN_SLASH_COMMANDS, piSessionsRoot } from '../pi-vendored.js';
+import { isDeterministicCommandExpansion } from '../command-expansion.js';
+function registryOf(session) {
+    return new ModelRegistry(session.modelRuntime);
+}
+const toModelRef = (model) => model === undefined || isUnknownModel(model) ? null : { provider: model.provider, id: model.id };
+export const modelKey = (model) => `${model.provider}/${model.id}`;
+export function buildCommandList(session) {
+    const out = [];
+    for (const builtin of BUILTIN_SLASH_COMMANDS)
+        out.push({ name: builtin.name, description: builtin.description, source: 'builtin' });
+    try {
+        for (const command of session.extensionRunner.getRegisteredCommands()) {
+            const expansion = command.expansion;
+            out.push({
+                name: command.invocationName,
+                description: command.description ?? '',
+                source: 'command',
+                ...(isDeterministicCommandExpansion(expansion) ? { expansion } : {}),
+            });
+        }
+    }
+    catch {
+        /* engine without a live extensionRunner — builtins only */
+    }
+    try {
+        for (const template of session.promptTemplates)
+            out.push({ name: template.name, description: template.description, source: 'template', template: template.content });
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+export function buildListMemoryRefsData(id, refs, engineLeadingCommandNames) {
+    return { type: 'data', id, kind: 'list_memory_refs', refs, engineLeadingCommandNames };
+}
+export function buildListModelsData(id, session) {
+    const registry = registryOf(session);
+    let availableIds = [];
+    try {
+        availableIds = registry.getAvailable().map(modelKey);
+    }
+    catch {
+        /* getAvailable touches auth config; degrade to none known available */
+    }
+    return {
+        type: 'data',
+        id,
+        kind: 'list_models',
+        models: registry.getAll(),
+        current: toModelRef(session.model),
+        availableIds,
+        scopedModels: session.scopedModels.map((scoped) => ({ model: scoped.model, thinkingLevel: scoped.thinkingLevel })),
+        enabledModelIds: session.settingsManager.getEnabledModels() ?? null,
+    };
+}
+export function buildScopedModelsData(id, session) {
+    return {
+        type: 'data',
+        id,
+        kind: 'list_scoped_models',
+        allModels: registryOf(session).getAll(),
+        enabledModelIds: session.settingsManager.getEnabledModels() ?? null,
+    };
+}
+export function buildGetTreeData(id, session, reviewCompanion) {
+    const manager = session.sessionManager;
+    const tree = reviewCompanion ? boundaryRootedTree(manager.getTree()) : manager.getTree();
+    const visibleEntryIds = new Set();
+    const collectEntryIds = (nodes) => {
+        for (const node of nodes) {
+            visibleEntryIds.add(node.entry.id);
+            collectEntryIds(node.children);
+        }
+    };
+    collectEntryIds(tree);
+    const forkPoints = session.getUserMessagesForForking()
+        .filter((user) => visibleEntryIds.has(user.entryId))
+        .map((user) => ({ id: user.entryId, text: user.text, timestamp: manager.getEntry(user.entryId)?.timestamp }));
+    const currentLeafId = manager.getLeafId();
+    return {
+        type: 'data',
+        id,
+        kind: 'get_tree',
+        tree,
+        currentLeafId: currentLeafId !== null && visibleEntryIds.has(currentLeafId) ? currentLeafId : null,
+        forkPoints,
+    };
+}
+export function buildSettingsData(id, session) {
+    const manager = session.settingsManager;
+    let availableThemes = [];
+    try {
+        availableThemes = session.resourceLoader.getThemes().themes.map((theme) => theme.name ?? '').filter((name) => name !== '');
+    }
+    catch {
+        /* loader without themes — viewer falls back to its local theme registry */
+    }
+    const settings = {
+        autoCompact: session.autoCompactionEnabled,
+        showImages: manager.getShowImages(),
+        imageWidthCells: manager.getImageWidthCells(),
+        autoResizeImages: manager.getImageAutoResize(),
+        blockImages: manager.getBlockImages(),
+        enableSkillCommands: manager.getEnableSkillCommands(),
+        steeringMode: session.steeringMode,
+        followUpMode: session.followUpMode,
+        transport: manager.getTransport(),
+        httpIdleTimeoutMs: manager.getHttpIdleTimeoutMs(),
+        thinkingLevel: session.thinkingLevel,
+        availableThinkingLevels: session.getAvailableThinkingLevels(),
+        currentTheme: manager.getTheme() ?? '',
+        terminalTheme: 'dark',
+        availableThemes,
+        hideThinkingBlock: manager.getHideThinkingBlock(),
+        collapseChangelog: manager.getCollapseChangelog(),
+        enableInstallTelemetry: manager.getEnableInstallTelemetry(),
+        doubleEscapeAction: manager.getDoubleEscapeAction(),
+        treeFilterMode: manager.getTreeFilterMode(),
+        showHardwareCursor: manager.getShowHardwareCursor(),
+        editorPaddingX: manager.getEditorPaddingX(),
+        autocompleteMaxVisible: manager.getAutocompleteMaxVisible(),
+        quietStartup: manager.getQuietStartup(),
+        clearOnShrink: manager.getClearOnShrink(),
+        showTerminalProgress: manager.getShowTerminalProgress(),
+        warnings: manager.getWarnings(),
+        defaultProjectTrust: manager.getDefaultProjectTrust(),
+        showCacheMissNotices: manager.getShowCacheMissNotices(),
+        outputPad: manager.getOutputPad(),
+        autoRetry: session.autoRetryEnabled,
+        model: toModelRef(session.model),
+    };
+    return { type: 'data', id, kind: 'get_settings', settings };
+}
+export function buildSessionsData(id, scope, session, cache) {
+    const manager = session.sessionManager;
+    const sessionDir = manager.getSessionDir();
+    return (scope === 'all' ? cache.listAll(piSessionsRoot()) : cache.listDir(sessionDir)).then((sessions) => ({
+        type: 'data',
+        id,
+        kind: 'list_sessions',
+        scope,
+        sessions,
+        currentSessionFile: session.sessionFile,
+    }));
+}

package/dist/core/runtime/broker/rebind.d.ts

@@ -0,0 +1,74 @@
+import type { AgentSessionRuntime, AgentSessionServices, ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { BrokerSdkConfig } from '../launch.js';
+import type { BrokerClientRegistry, BrokerClient } from './client-registry.js';
+import type { FaultRetry } from './fault-retry.js';
+import type { EventProjection } from './event-projection.js';
+import type { BrokerSession } from './read-ops.js';
+import type { ToolGroupTracker } from './tool-groups.js';
+import type { OperationId } from '../../events/types.js';
+export interface SubscriptionGeneration {
+    id: number;
+    session: BrokerSession;
+    fallback: {
+        storedId?: OperationId;
+        blocked: boolean;
+    };
+    stagedProviderAgentEnd: {
+        messages?: unknown[];
+    } | null;
+    stagedWatchdogAbort: boolean;
+    stagedOverflowFailure: {
+        errorMessage: string;
+    } | null;
+    executingTools: Set<string>;
+}
+type RebindDriverDeps = {
+    nodeId: string;
+    cfg: BrokerSdkConfig;
+    session: BrokerSession;
+    services: AgentSessionServices;
+    runtime: AgentSessionRuntime | undefined;
+    uiContext: () => ExtensionUIContext;
+    registry: BrokerClientRegistry;
+    toolGroups: ToolGroupTracker;
+    faultRetry: () => FaultRetry;
+    projection: () => EventProjection;
+    setActiveSession: (session: {
+        dispose: () => void;
+    }) => void;
+    disposeAndExit: (reason: string, status?: number) => void;
+    onSessionRebind: () => void;
+    reWelcomeAll: () => void;
+};
+/** Owns session subscription replacement, its serialization lane, and replacement admission policy. */
+export declare class RebindDriver {
+    private readonly deps;
+    private sessionValue;
+    private servicesValue;
+    private unsubscribe;
+    private installed;
+    private nextSubscriptionGeneration;
+    private rebindTail;
+    private latestRebindRequest;
+    private replacementTail;
+    private admittedReplacements;
+    private agentRunActiveValue;
+    private shutdownRequested;
+    constructor(deps: RebindDriverDeps);
+    session(): BrokerSession;
+    services(): AgentSessionServices;
+    installedGeneration(): SubscriptionGeneration | undefined;
+    isAgentRunActive(): boolean;
+    requestShutdown(): void;
+    setRebindSession(): void;
+    enqueueRebind(candidateSession: BrokerSession, candidateServices: AgentSessionServices): Promise<void>;
+    runReplacement(client: BrokerClient, op: string, run: (runtime: AgentSessionRuntime) => Promise<{
+        cancelled: boolean;
+        detail?: string;
+    }>): void;
+    private removeInstalledSubscription;
+    private captureSystemPrompt;
+    private executeSubscriptionCallback;
+    private ackTo;
+}
+export {};