@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/router/virtual-router/pre-command-file-resolver.js

@@ -0,0 +1,90 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import os from 'node:os';
+function resolveRoutecodexUserDir() {
+    const override = process.env.ROUTECODEX_USER_DIR;
+    if (override && override.trim()) {
+        return override.trim();
+    }
+    const home = os.homedir();
+    if (!home) {
+        throw new Error('precommand: cannot resolve homedir');
+    }
+    return path.join(home, '.routecodex');
+}
+function resolvePreCommandBaseDir() {
+    return path.resolve(resolveRoutecodexUserDir(), 'precommand');
+}
+function normalizeRelativePath(raw) {
+    const normalized = path.posix.normalize(raw.replace(/\\/g, '/'));
+    if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
+        throw new Error('precommand: invalid relative path');
+    }
+    return normalized;
+}
+function normalizePreCommandRelativePath(raw, fromFileScheme) {
+    const normalized = normalizeRelativePath(raw);
+    if (normalized === 'precommand') {
+        throw new Error('precommand: expected script file under ~/.routecodex/precommand');
+    }
+    if (normalized.startsWith('precommand/')) {
+        return normalized.slice('precommand/'.length);
+    }
+    if (fromFileScheme) {
+        throw new Error('precommand file://: path must be under file://precommand/...');
+    }
+    return normalized;
+}
+export function resolvePreCommandScriptPath(raw) {
+    let text = typeof raw === 'string' ? raw.trim() : '';
+    if (!text) {
+        throw new Error('precommand: missing script path');
+    }
+    if (text.startsWith('<') && text.endsWith('>') && text.length >= 3) {
+        text = text.slice(1, -1).trim();
+    }
+    const fromFileScheme = /^file:\/\//i.test(text);
+    const relRaw = fromFileScheme ? text.slice('file://'.length).trim() : text;
+    if (!relRaw) {
+        throw new Error('precommand file://: missing relative path');
+    }
+    if (relRaw.startsWith('/') || relRaw.startsWith('\\') || /^[a-zA-Z]:[\\/]/.test(relRaw)) {
+        throw new Error('precommand: only supports paths relative to ~/.routecodex/precommand');
+    }
+    const relToPreCommand = normalizePreCommandRelativePath(relRaw, fromFileScheme);
+    const base = resolvePreCommandBaseDir();
+    const abs = path.resolve(base, relToPreCommand);
+    if (abs !== base && !abs.startsWith(`${base}${path.sep}`)) {
+        throw new Error('precommand: path escapes ~/.routecodex/precommand');
+    }
+    let stat;
+    try {
+        stat = fs.statSync(abs);
+    }
+    catch (err) {
+        const message = err && typeof err.message === 'string' ? err.message : String(err || 'unknown error');
+        throw new Error(`precommand: cannot stat ${abs}: ${message}`);
+    }
+    if (!stat.isFile()) {
+        throw new Error(`precommand: not a file: ${abs}`);
+    }
+    return abs;
+}
+export function isPreCommandScriptPathAllowed(rawPath) {
+    const scriptPath = typeof rawPath === 'string' ? rawPath.trim() : '';
+    if (!scriptPath) {
+        return false;
+    }
+    const base = resolvePreCommandBaseDir();
+    const abs = path.resolve(scriptPath);
+    if (abs !== base && !abs.startsWith(`${base}${path.sep}`)) {
+        return false;
+    }
+    try {
+        const stat = fs.statSync(abs);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/router/virtual-router/provider-registry.js

@@ -84,7 +84,8 @@ export class ProviderRegistry {
             processMode: profile.processMode || 'chat',
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
-            maxContextTokens: profile.maxContextTokens
+            maxContextTokens: profile.maxContextTokens,
+            ...(profile.deepseek ? { deepseek: profile.deepseek } : {})
         };
     }
     static normalizeProfile(key, profile) {
@@ -103,6 +104,7 @@ export class ProviderRegistry {
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
             maxContextTokens: profile.maxContextTokens,
+            ...(profile.deepseek ? { deepseek: profile.deepseek } : {}),
             ...(profile.serverToolsDisabled ? { serverToolsDisabled: true } : {})
         };
     }

package/dist/router/virtual-router/routing-instructions.d.ts

@@ -1,13 +1,16 @@
 import type { StandardizedMessage } from '../../conversion/hub/types/standardized.js';
 export interface RoutingInstruction {
-    type: 'force' | 'sticky' | 'prefer' | 'disable' | 'enable' | 'clear' | 'allow' | 'stopMessageSet' | 'stopMessageClear';
+    type: 'force' | 'sticky' | 'prefer' | 'disable' | 'enable' | 'clear' | 'allow' | 'stopMessageSet' | 'stopMessageMode' | 'stopMessageClear' | 'preCommandSet' | 'preCommandClear';
     provider?: string;
     keyAlias?: string;
     keyIndex?: number;
     model?: string;
     pathLength?: number;
+    processMode?: 'chat' | 'passthrough';
     stopMessageText?: string;
     stopMessageMaxRepeats?: number;
+    stopMessageStageMode?: 'on' | 'off' | 'auto';
+    preCommandScriptPath?: string;
 }
 export interface RoutingInstructionState {
     forcedTarget?: {
@@ -16,6 +19,7 @@ export interface RoutingInstructionState {
         keyIndex?: number;
         model?: string;
         pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
     };
     stickyTarget?: {
         provider?: string;
@@ -23,6 +27,7 @@ export interface RoutingInstructionState {
         keyIndex?: number;
         model?: string;
         pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
     };
     preferTarget?: {
         provider?: string;
@@ -30,6 +35,7 @@ export interface RoutingInstructionState {
         keyIndex?: number;
         model?: string;
         pathLength?: number;
+        processMode?: 'chat' | 'passthrough';
     };
     allowedProviders: Set<string>;
     disabledProviders: Set<string>;
@@ -46,6 +52,14 @@ export interface RoutingInstructionState {
     stopMessageUsed?: number;
     stopMessageUpdatedAt?: number;
     stopMessageLastUsedAt?: number;
+    stopMessageStage?: string;
+    stopMessageStageMode?: 'on' | 'off' | 'auto';
+    stopMessageObservationHash?: string;
+    stopMessageObservationStableCount?: number;
+    stopMessageBdWorkState?: string;
+    preCommandSource?: string;
+    preCommandScriptPath?: string;
+    preCommandUpdatedAt?: number;
 }
 export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
 /**

package/dist/router/virtual-router/routing-instructions.js

@@ -1,5 +1,10 @@
 import { extractMessageText } from './message-utils.js';
-import { resolveStopMessageText } from './stop-message-file-resolver.js';
+import { parseStopMessageInstruction } from './routing-stop-message-parser.js';
+import { applyStopMessageInstructionToState } from './routing-stop-message-actions.js';
+import { parsePreCommandInstruction } from './routing-pre-command-parser.js';
+import { applyPreCommandInstructionToState, clearPreCommandState } from './routing-pre-command-actions.js';
+import { deserializeStopMessageState, serializeStopMessageState } from './routing-stop-message-state-codec.js';
+import { deserializePreCommandState, serializePreCommandState } from './routing-pre-command-state-codec.js';
 export function parseRoutingInstructions(messages) {
     const instructions = [];
     // 从最新一条携带路由指令标记（<** ... **>）的 user 消息中解析指令，
@@ -45,10 +50,8 @@ export function parseRoutingInstructions(messages) {
         for (const segment of segments) {
             const parsed = parseSingleInstruction(segment);
             if (parsed) {
-                // stopMessage is a "command" and must only be set/cleared from the *latest* user message.
-                // Otherwise, clients that resend full history (including a past "<**stopMessage:...**>" message)
-                // would keep re-applying stopMessage after it has been consumed/cleared.
-                if ((parsed.type === 'stopMessageSet' || parsed.type === 'stopMessageClear') &&
+                // preCommand 是强副作用命令（执行本地脚本），仅允许从 latest user message 生效。
+                if ((parsed.type === 'preCommandSet' || parsed.type === 'preCommandClear') &&
                     lastUserIndex >= 0 &&
                     sanitizedIndex >= 0 &&
                     sanitizedIndex !== lastUserIndex) {
@@ -105,7 +108,7 @@ function expandInstructionSegments(instruction) {
     }
     // stopMessage 指令需要整体解析，不能按逗号拆分，否则类似
     // "<**stopMessage:\"继续\",3**>" 会被错误拆成 ["stopMessage:\"继续\"", "3"]。
-    if (/^stopMessage\s*:/i.test(trimmed)) {
+    if (/^stopMessage\s*:/i.test(trimmed) || /^precommand(?:\s*:|$)/i.test(trimmed)) {
         return [trimmed];
     }
     const prefix = trimmed[0];
@@ -124,80 +127,75 @@ function splitInstructionTargets(content) {
         .map((segment) => segment.trim())
         .filter((segment) => segment.length > 0);
 }
+function splitTargetAndProcessMode(rawTarget) {
+    const trimmed = typeof rawTarget === 'string' ? rawTarget.trim() : '';
+    if (!trimmed) {
+        return { target: '' };
+    }
+    const separatorIndex = trimmed.lastIndexOf(':');
+    if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        return { target: trimmed };
+    }
+    const target = trimmed.slice(0, separatorIndex).trim();
+    const modeToken = trimmed.slice(separatorIndex + 1).trim().toLowerCase();
+    if (!target) {
+        return { target: trimmed };
+    }
+    if (modeToken === 'passthrough') {
+        return { target, processMode: 'passthrough' };
+    }
+    if (modeToken === 'chat') {
+        return { target, processMode: 'chat' };
+    }
+    return { target };
+}
+function parseNamedTargetInstruction(instruction, prefix) {
+    const re = new RegExp('^' + prefix + '\\s*:', 'i');
+    if (!re.test(instruction)) {
+        return null;
+    }
+    const body = instruction.slice(instruction.indexOf(':') + 1).trim();
+    if (!body) {
+        return null;
+    }
+    const { target, processMode } = splitTargetAndProcessMode(body);
+    if (!target) {
+        return null;
+    }
+    const parsed = parseTarget(target);
+    if (!parsed) {
+        return null;
+    }
+    const normalized = normalizeStickyOrForceTarget(parsed);
+    return { type: prefix, ...normalized, ...(processMode ? { processMode } : {}) };
+}
 function parseSingleInstruction(instruction) {
     if (instruction === 'clear') {
         return { type: 'clear' };
     }
-    if (/^stopMessage\s*:/i.test(instruction)) {
-        const body = instruction.slice('stopMessage'.length + 1).trim();
-        if (!body) {
-            return null;
-        }
-        if (/^clear$/i.test(body)) {
-            return { type: 'stopMessageClear' };
-        }
-        let text = '';
-        let maxRepeats = 1;
-        let cursor = body;
-        if (cursor[0] === '"') {
-            let escaped = false;
-            let endIndex = -1;
-            for (let i = 1; i < cursor.length; i += 1) {
-                const ch = cursor[i];
-                if (escaped) {
-                    escaped = false;
-                    continue;
-                }
-                if (ch === '\\') {
-                    escaped = true;
-                    continue;
-                }
-                if (ch === '"') {
-                    endIndex = i;
-                    break;
-                }
-            }
-            if (endIndex <= 0) {
-                return null;
-            }
-            const rawText = cursor.slice(1, endIndex);
-            text = rawText.replace(/\\"/g, '"');
-            cursor = cursor.slice(endIndex + 1).trim();
-            if (cursor.startsWith(',')) {
-                const countRaw = cursor.slice(1).trim();
-                if (countRaw) {
-                    const parsed = Number.parseInt(countRaw, 10);
-                    if (!Number.isNaN(parsed) && parsed > 0) {
-                        maxRepeats = parsed;
-                    }
-                }
-            }
-        }
-        else {
-            // 支持无引号的简单形式：stopMessage:继续,3
-            const parts = cursor.split(',').map((part) => part.trim()).filter(Boolean);
-            if (!parts.length) {
-                return null;
-            }
-            text = parts[0];
-            if (parts.length > 1) {
-                const parsed = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(parsed) && parsed > 0) {
-                    maxRepeats = parsed;
-                }
-            }
-        }
-        if (!text) {
-            return null;
-        }
-        return {
-            type: 'stopMessageSet',
-            stopMessageText: resolveStopMessageText(text),
-            stopMessageMaxRepeats: maxRepeats
-        };
+    const preCommandInstruction = parsePreCommandInstruction(instruction);
+    if (preCommandInstruction) {
+        return preCommandInstruction;
+    }
+    const stopMessageInstruction = parseStopMessageInstruction(instruction);
+    if (stopMessageInstruction) {
+        return stopMessageInstruction;
+    }
+    const stickyInstruction = parseNamedTargetInstruction(instruction, 'sticky');
+    if (stickyInstruction) {
+        return stickyInstruction;
+    }
+    const forceInstruction = parseNamedTargetInstruction(instruction, 'force');
+    if (forceInstruction) {
+        return forceInstruction;
+    }
+    const preferInstruction = parseNamedTargetInstruction(instruction, 'prefer');
+    if (preferInstruction) {
+        return preferInstruction;
     }
     if (instruction.startsWith('!')) {
-        const target = instruction.substring(1).trim();
+        const rawTarget = instruction.substring(1).trim();
+        const { target, processMode } = splitTargetAndProcessMode(rawTarget);
         if (!target) {
             return null;
         }
@@ -218,7 +216,7 @@ function parseSingleInstruction(instruction) {
             return null;
         }
         const normalized = normalizeStickyOrForceTarget(parsed);
-        return { type: 'prefer', ...normalized };
+        return { type: 'prefer', ...normalized, ...(processMode ? { processMode } : {}) };
     }
     else if (instruction.startsWith('#')) {
         const target = instruction.substring(1).trim();
@@ -362,11 +360,20 @@ export function applyRoutingInstructions(instructions, currentState) {
         disabledProviders: new Set(currentState.disabledProviders),
         disabledKeys: new Map(Array.from(currentState.disabledKeys.entries()).map(([k, v]) => [k, new Set(v)])),
         disabledModels: new Map(Array.from(currentState.disabledModels.entries()).map(([k, v]) => [k, new Set(v)])),
+        stopMessageSource: currentState.stopMessageSource,
         stopMessageText: currentState.stopMessageText,
         stopMessageMaxRepeats: currentState.stopMessageMaxRepeats,
         stopMessageUsed: currentState.stopMessageUsed,
         stopMessageUpdatedAt: currentState.stopMessageUpdatedAt,
-        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt
+        stopMessageLastUsedAt: currentState.stopMessageLastUsedAt,
+        stopMessageStage: currentState.stopMessageStage,
+        stopMessageStageMode: currentState.stopMessageStageMode,
+        stopMessageObservationHash: currentState.stopMessageObservationHash,
+        stopMessageObservationStableCount: currentState.stopMessageObservationStableCount,
+        stopMessageBdWorkState: currentState.stopMessageBdWorkState,
+        preCommandSource: currentState.preCommandSource,
+        preCommandScriptPath: currentState.preCommandScriptPath,
+        preCommandUpdatedAt: currentState.preCommandUpdatedAt
     };
     let allowReset = false;
     let disableReset = false;
@@ -378,7 +385,8 @@ export function applyRoutingInstructions(instructions, currentState) {
                     keyAlias: instruction.keyAlias,
                     keyIndex: instruction.keyIndex,
                     model: instruction.model,
-                    pathLength: instruction.pathLength
+                    pathLength: instruction.pathLength,
+                    processMode: instruction.processMode
                 };
                 // 保留 stickyTarget，允许单次 force 覆盖但不清除持久 sticky
                 // newState.stickyTarget = undefined;
@@ -389,7 +397,8 @@ export function applyRoutingInstructions(instructions, currentState) {
                     keyAlias: instruction.keyAlias,
                     keyIndex: instruction.keyIndex,
                     model: instruction.model,
-                    pathLength: instruction.pathLength
+                    pathLength: instruction.pathLength,
+                    processMode: instruction.processMode
                 };
                 newState.forcedTarget = undefined;
                 break;
@@ -399,7 +408,8 @@ export function applyRoutingInstructions(instructions, currentState) {
                     keyAlias: instruction.keyAlias,
                     keyIndex: instruction.keyIndex,
                     model: instruction.model,
-                    pathLength: instruction.pathLength
+                    pathLength: instruction.pathLength,
+                    processMode: instruction.processMode
                 };
                 newState.forcedTarget = undefined;
                 newState.stickyTarget = undefined;
@@ -490,43 +500,16 @@ export function applyRoutingInstructions(instructions, currentState) {
                 newState.disabledProviders.clear();
                 newState.disabledKeys.clear();
                 newState.disabledModels.clear();
+                clearPreCommandState(newState);
                 break;
-            case 'stopMessageSet': {
-                const text = typeof instruction.stopMessageText === 'string' && instruction.stopMessageText.trim()
-                    ? instruction.stopMessageText.trim()
-                    : '';
-                const maxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
-                    ? Math.floor(instruction.stopMessageMaxRepeats)
-                    : 0;
-                if (text && maxRepeats > 0) {
-                    const sameText = typeof newState.stopMessageText === 'string' &&
-                        newState.stopMessageText.trim() === text;
-                    const sameMax = typeof newState.stopMessageMaxRepeats === 'number' &&
-                        Math.floor(newState.stopMessageMaxRepeats) === maxRepeats;
-                    const isSameInstruction = sameText && sameMax;
-                    const used = typeof newState.stopMessageUsed === 'number' && Number.isFinite(newState.stopMessageUsed)
-                        ? Math.max(0, Math.floor(newState.stopMessageUsed))
-                        : 0;
-                    const hasLastUsedAt = typeof newState.stopMessageLastUsedAt === 'number' && Number.isFinite(newState.stopMessageLastUsedAt);
-                    const shouldRearm = !isSameInstruction || used > 0 || hasLastUsedAt;
-                    newState.stopMessageText = text;
-                    newState.stopMessageMaxRepeats = maxRepeats;
-                    newState.stopMessageSource = 'explicit';
-                    if (shouldRearm) {
-                        newState.stopMessageUsed = 0;
-                        newState.stopMessageUpdatedAt = Date.now();
-                        newState.stopMessageLastUsedAt = undefined;
-                    }
-                }
-                break;
-            }
+            case 'stopMessageSet':
+            case 'stopMessageMode':
             case 'stopMessageClear':
-                newState.stopMessageText = undefined;
-                newState.stopMessageMaxRepeats = undefined;
-                newState.stopMessageUsed = undefined;
-                newState.stopMessageSource = undefined;
-                newState.stopMessageUpdatedAt = undefined;
-                newState.stopMessageLastUsedAt = undefined;
+                applyStopMessageInstructionToState(instruction, newState);
+                break;
+            case 'preCommandSet':
+            case 'preCommandClear':
+                applyPreCommandInstructionToState(instruction, newState);
                 break;
         }
     }
@@ -569,24 +552,8 @@ export function serializeRoutingInstructionState(state) {
             provider,
             models: Array.from(models)
         })),
-        ...(typeof state.stopMessageSource === 'string' && state.stopMessageSource.trim()
-            ? { stopMessageSource: state.stopMessageSource }
-            : {}),
-        ...(typeof state.stopMessageText === 'string' && state.stopMessageText.trim()
-            ? { stopMessageText: state.stopMessageText }
-            : {}),
-        ...(typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-            ? { stopMessageMaxRepeats: state.stopMessageMaxRepeats }
-            : {}),
-        ...(typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-            ? { stopMessageUsed: state.stopMessageUsed }
-            : {}),
-        ...(typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)
-            ? { stopMessageUpdatedAt: state.stopMessageUpdatedAt }
-            : {}),
-        ...(typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
-            ? { stopMessageLastUsedAt: state.stopMessageLastUsedAt }
-            : {})
+        ...serializeStopMessageState(state),
+        ...serializePreCommandState(state)
     };
 }
 export function deserializeRoutingInstructionState(data) {
@@ -599,8 +566,16 @@ export function deserializeRoutingInstructionState(data) {
         disabledKeys: new Map(),
         disabledModels: new Map(),
         stopMessageText: undefined,
+        stopMessageSource: undefined,
         stopMessageMaxRepeats: undefined,
-        stopMessageUsed: undefined
+        stopMessageUsed: undefined,
+        stopMessageStage: undefined,
+        stopMessageStageMode: undefined,
+        stopMessageObservationHash: undefined,
+        stopMessageBdWorkState: undefined,
+        preCommandSource: undefined,
+        preCommandScriptPath: undefined,
+        preCommandUpdatedAt: undefined
     };
     if (data.forcedTarget && typeof data.forcedTarget === 'object') {
         state.forcedTarget = data.forcedTarget;
@@ -631,23 +606,7 @@ export function deserializeRoutingInstructionState(data) {
             }
         }
     }
-    if (typeof data.stopMessageSource === 'string' && data.stopMessageSource.trim()) {
-        state.stopMessageSource = data.stopMessageSource.trim();
-    }
-    if (typeof data.stopMessageText === 'string' && data.stopMessageText.trim()) {
-        state.stopMessageText = data.stopMessageText;
-    }
-    if (typeof data.stopMessageMaxRepeats === 'number' && Number.isFinite(data.stopMessageMaxRepeats)) {
-        state.stopMessageMaxRepeats = Math.floor(data.stopMessageMaxRepeats);
-    }
-    if (typeof data.stopMessageUsed === 'number' && Number.isFinite(data.stopMessageUsed)) {
-        state.stopMessageUsed = Math.max(0, Math.floor(data.stopMessageUsed));
-    }
-    if (typeof data.stopMessageUpdatedAt === 'number' && Number.isFinite(data.stopMessageUpdatedAt)) {
-        state.stopMessageUpdatedAt = data.stopMessageUpdatedAt;
-    }
-    if (typeof data.stopMessageLastUsedAt === 'number' && Number.isFinite(data.stopMessageLastUsedAt)) {
-        state.stopMessageLastUsedAt = data.stopMessageLastUsedAt;
-    }
+    deserializeStopMessageState(data, state);
+    deserializePreCommandState(data, state);
     return state;
 }

package/dist/router/virtual-router/routing-pre-command-actions.d.ts

@@ -0,0 +1,3 @@
+import type { RoutingInstruction, RoutingInstructionState } from './routing-instructions.js';
+export declare function applyPreCommandInstructionToState(instruction: RoutingInstruction, state: RoutingInstructionState): boolean;
+export declare function clearPreCommandState(state: RoutingInstructionState): void;

package/dist/router/virtual-router/routing-pre-command-actions.js

@@ -0,0 +1,26 @@
+export function applyPreCommandInstructionToState(instruction, state) {
+    switch (instruction.type) {
+        case 'preCommandSet': {
+            const scriptPath = typeof instruction.preCommandScriptPath === 'string' && instruction.preCommandScriptPath.trim()
+                ? instruction.preCommandScriptPath.trim()
+                : '';
+            if (!scriptPath) {
+                return true;
+            }
+            state.preCommandScriptPath = scriptPath;
+            state.preCommandSource = 'explicit';
+            state.preCommandUpdatedAt = Date.now();
+            return true;
+        }
+        case 'preCommandClear':
+            clearPreCommandState(state);
+            return true;
+        default:
+            return false;
+    }
+}
+export function clearPreCommandState(state) {
+    state.preCommandScriptPath = undefined;
+    state.preCommandSource = undefined;
+    state.preCommandUpdatedAt = undefined;
+}

package/dist/router/virtual-router/routing-pre-command-parser.d.ts

@@ -0,0 +1,2 @@
+import type { RoutingInstruction } from './routing-instructions.js';
+export declare function parsePreCommandInstruction(instruction: string): RoutingInstruction | null;

package/dist/router/virtual-router/routing-pre-command-parser.js

@@ -0,0 +1,85 @@
+import { resolvePreCommandScriptPath } from './pre-command-file-resolver.js';
+const DEFAULT_PRECOMMAND_SCRIPT = 'default.sh';
+export function parsePreCommandInstruction(instruction) {
+    const trimmed = typeof instruction === 'string' ? instruction.trim() : '';
+    if (!trimmed) {
+        return null;
+    }
+    if (/^precommand$/i.test(trimmed)) {
+        return {
+            type: 'preCommandSet',
+            preCommandScriptPath: resolvePreCommandScriptPath(resolveDefaultScriptRef())
+        };
+    }
+    if (!/^precommand\s*:/i.test(trimmed)) {
+        return null;
+    }
+    const body = trimmed.slice('precommand'.length + 1).trim();
+    if (!body) {
+        return null;
+    }
+    const parsedValue = readPreCommandToken(body);
+    if (!parsedValue) {
+        return null;
+    }
+    const normalized = parsedValue.trim();
+    if (!normalized) {
+        return null;
+    }
+    if (/^(?:clear|off|none)$/i.test(normalized)) {
+        return { type: 'preCommandClear' };
+    }
+    if (/^on$/i.test(normalized)) {
+        return {
+            type: 'preCommandSet',
+            preCommandScriptPath: resolvePreCommandScriptPath(resolveDefaultScriptRef())
+        };
+    }
+    return {
+        type: 'preCommandSet',
+        preCommandScriptPath: resolvePreCommandScriptPath(normalized)
+    };
+}
+function resolveDefaultScriptRef() {
+    const configured = process.env.ROUTECODEX_PRECOMMAND_DEFAULT_SCRIPT;
+    if (typeof configured === 'string' && configured.trim()) {
+        return configured.trim();
+    }
+    return DEFAULT_PRECOMMAND_SCRIPT;
+}
+function readPreCommandToken(body) {
+    if (!body) {
+        return null;
+    }
+    const first = body[0];
+    if (first === '"' || first === "'") {
+        const end = findClosingQuote(body, first);
+        if (end <= 0) {
+            return null;
+        }
+        return body.slice(1, end).replace(/\\"/g, '"').replace(/\\'/g, "'");
+    }
+    const comma = body.indexOf(',');
+    if (comma >= 0) {
+        return body.slice(0, comma).trim();
+    }
+    return body.trim();
+}
+function findClosingQuote(text, quote) {
+    let escaped = false;
+    for (let idx = 1; idx < text.length; idx += 1) {
+        const ch = text[idx];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (ch === quote) {
+            return idx;
+        }
+    }
+    return -1;
+}

package/dist/router/virtual-router/routing-pre-command-state-codec.d.ts

@@ -0,0 +1,3 @@
+import type { RoutingInstructionState } from './routing-instructions.js';
+export declare function serializePreCommandState(state: RoutingInstructionState): Record<string, unknown>;
+export declare function deserializePreCommandState(data: Record<string, unknown>, state: RoutingInstructionState): void;