evolcore 0.0.29 → 0.0.30

package/dist/trigger/ipc-service.js

@@ -0,0 +1,406 @@
+import fs from 'fs';
+import path from 'path';
+import { getEventCatalog } from '../core/event-catalog.js';
+import { authorizeOperation, canApprovePersistentFullAccessTrigger, isCrossAgentTriggerOperationAllowed, } from '../core/auth/auth-gateway.js';
+import { auditFullAccessEvent } from '../core/auth/authorization-audit.js';
+import { assertTriggerLocalFileAuthority, daemonPrivilegedTriggerReason, } from './authorization.js';
+import { decodeTriggerScriptFile, resolveTriggerLocalPath } from './local-files.js';
+import { applyTriggerPatch } from './patch.js';
+import { definitionRevision, normalizeTriggerDefinition, splitScriptCommand } from './validation.js';
+export function createTriggerBaseagentResolver({ daemonTriggerOwnerAid, getAgentName, getDaemonAgentName, agentMap, }) {
+    return agentAid => {
+        const ownerName = getAgentName(agentAid)
+            ?? (agentAid === daemonTriggerOwnerAid ? getDaemonAgentName() : undefined);
+        if (!ownerName)
+            return [];
+        const prefix = `${ownerName}::`;
+        return [...agentMap.keys()]
+            .filter(key => key.startsWith(prefix))
+            .map(key => key.slice(prefix.length));
+    };
+}
+export function registerTriggerIpcExecutor(ipcServer, dependencies) {
+    ipcServer.setTriggerExecutor(createTriggerIpcExecutor(dependencies));
+}
+export function materializeTriggerCreateBaseagent(input, agentAid, dependencies) {
+    const rawExecution = input.execution;
+    if (!rawExecution || typeof rawExecution !== 'object' || Array.isArray(rawExecution))
+        return input;
+    const execution = rawExecution;
+    if (execution.type !== 'trigger_session') {
+        if (execution.baseagent !== undefined) {
+            throw new Error('execution.baseagent is only allowed when execution.type=trigger_session');
+        }
+        return input;
+    }
+    if (execution.baseagent !== undefined
+        && (typeof execution.baseagent !== 'string' || !execution.baseagent.trim())) {
+        throw new Error('execution.baseagent must be a non-empty string');
+    }
+    const baseagent = typeof execution.baseagent === 'string'
+        ? execution.baseagent.trim()
+        : dependencies.getAgentBaseagent(agentAid)
+            ?? (agentAid === dependencies.daemonTriggerOwnerAid ? dependencies.daemonTriggerBaseagent : undefined);
+    if (!baseagent)
+        throw new Error('unable to resolve Trigger session baseagent');
+    const available = dependencies.getAvailableBaseagents(agentAid);
+    if (!available.includes(baseagent)) {
+        throw new Error(`Trigger baseagent unavailable for ${agentAid}: ${baseagent} (available: ${available.join(', ') || 'none'})`);
+    }
+    return { ...input, execution: { ...execution, baseagent } };
+}
+export function createTriggerIpcExecutor(dependencies) {
+    return async (cmd) => {
+        const schedulerFor = (agentAid) => {
+            const scheduler = dependencies.getScheduler(agentAid);
+            if (!scheduler)
+                throw new Error(`trigger scheduler not found for agent: ${agentAid}`);
+            return scheduler;
+        };
+        const requireAgent = (agentAid) => {
+            if (typeof agentAid !== 'string' || !agentAid)
+                throw new Error('missing agentAid');
+            if (agentAid === dependencies.daemonTriggerOwnerAid)
+                return agentAid;
+            if (!dependencies.hasAgent(agentAid))
+                throw new Error(`agent not found: ${agentAid}`);
+            return agentAid;
+        };
+        const auditFullAccessTriggerConfiguration = (event, definition, actor, reason) => {
+            auditFullAccessEvent({
+                event,
+                source: 'trigger',
+                actorId: actor.origin.peerId,
+                processRole: actor.daemonOwner ? 'daemon-owner' : actor.subject.processRole,
+                authorizedBy: definition.authorizedBy,
+                agentAid: definition.agentAid,
+                triggerId: definition.id,
+                reason,
+            });
+        };
+        const rejectUnapprovedFullAccessConfiguration = (definition, actor) => {
+            const approvalSource = actor.control ? 'daemon-service' : 'agent-delegation';
+            if (definition.execution.permissionMode === 'fullaccess'
+                && !actor.fullAccess
+                && !canApprovePersistentFullAccessTrigger({
+                    daemonOwner: actor.daemonOwner,
+                    source: approvalSource,
+                })) {
+                throw new Error('persistent fullaccess Trigger requires an explicit user or management-channel action');
+            }
+        };
+        const withFullAccessConfigurationProvenance = (definition, actor) => {
+            if (definition.execution.permissionMode !== 'fullaccess') {
+                const { authorizedBy: _authorizedBy, ...deescalated } = definition;
+                return deescalated;
+            }
+            const authorizedBy = actor.fullAccess
+                ? actor.subject.authorizedBy
+                : actor.subject.principalId ?? actor.origin.peerId;
+            if (!authorizedBy)
+                throw new Error('fullaccess Trigger approval provenance is unavailable');
+            return { ...definition, authorizedBy };
+        };
+        const authorizeTrigger = async (agentAid, operation, triggerId, contextOnly = false) => {
+            const actor = await dependencies.authenticateActor(agentAid, cmd.actorSessionId, cmd.delegationToken, cmd.delegationCommandHash, cmd.controlToken, contextOnly);
+            if (actor.permissionMode === 'readonly' && !actor.fullAccess
+                && !['trigger.list', 'trigger.show', 'trigger.history', 'trigger.eventCatalog'].includes(operation)) {
+                throw new Error('readonly tasks cannot modify or run Triggers');
+            }
+            const isCrossAgent = !actor.control && actor.selfAid !== agentAid;
+            if (!isCrossAgentTriggerOperationAllowed({
+                control: actor.control,
+                daemonOwner: actor.daemonOwner || actor.fullAccess,
+                taskAgentAid: actor.selfAid,
+                targetAgentAid: agentAid,
+                targetManagement: actor.management,
+                operation,
+            })) {
+                if (isCrossAgent)
+                    throw new Error('cross-agent Trigger operations require DaemonOwner');
+                throw new Error('trigger agent does not match authenticated task agent');
+            }
+            const operationDecision = authorizeOperation({
+                source: actor.control ? 'control' : 'agent-tool',
+                subject: actor.subject,
+                intent: {
+                    operation,
+                    scope: 'relation',
+                    source: actor.control ? 'control' : 'agent-tool',
+                    args: {
+                        self: agentAid,
+                        taskAgentAid: actor.selfAid,
+                        targetAgentAid: agentAid,
+                        peer: actor.origin.peerId,
+                        peerKey: actor.subject.peerKey,
+                        ...(triggerId ? { triggerId } : {}),
+                    },
+                },
+            });
+            if (!operationDecision.allow)
+                throw new Error(operationDecision.reason);
+            if (!triggerId)
+                return actor;
+            const definition = schedulerFor(agentAid).list({ all: true }).find(trigger => trigger.id === triggerId);
+            const privilegedReason = definition ? daemonPrivilegedTriggerReason(definition) : undefined;
+            const persistedFullAccessApproval = privilegedReason === 'persistent fullaccess Trigger';
+            const deescalationOperation = operation === 'trigger.update'
+                || operation === 'trigger.setEnabled'
+                || operation === 'trigger.cancel'
+                || operation === 'trigger.delete';
+            if (privilegedReason && !persistedFullAccessApproval && !actor.daemonPrivileged && !deescalationOperation) {
+                throw new Error(`${privilegedReason} requires DaemonOwner`);
+            }
+            if (actor.management)
+                return actor;
+            if (!definition
+                || definition.origin?.peerId !== actor.origin?.peerId
+                || definition.origin?.channelKey !== actor.origin?.channelKey) {
+                throw new Error('trigger not found or access denied');
+            }
+            return actor;
+        };
+        switch (cmd.type) {
+            case 'trigger.authorizeLocalFiles': {
+                if (cmd.operation !== 'trigger.create' && cmd.operation !== 'trigger.update') {
+                    throw new Error('local file authorization only supports Trigger create/update');
+                }
+                const agentAid = requireAgent(cmd.agentAid);
+                if (cmd.operation === 'trigger.update' && (typeof cmd.triggerId !== 'string' || !cmd.triggerId)) {
+                    throw new Error('missing triggerId');
+                }
+                if (typeof cmd.actorSessionId !== 'string' || !cmd.actorSessionId) {
+                    throw new Error('local Trigger file authorization requires a managed task');
+                }
+                const actor = await authorizeTrigger(agentAid, cmd.operation, cmd.triggerId, true);
+                assertTriggerLocalFileAuthority(actor);
+                if (actor.fullAccess)
+                    return { ok: true, fullAccess: true };
+                const session = await dependencies.getSessionById(cmd.actorSessionId);
+                if (!session)
+                    throw new Error('Trigger actor session is unavailable');
+                if (typeof cmd.cwd !== 'string' || !path.isAbsolute(cmd.cwd))
+                    throw new Error('missing absolute command cwd');
+                const fileScope = {
+                    selfAid: agentAid,
+                    projectPath: fs.realpathSync.native(path.resolve(session.projectPath)),
+                    sessionRuntimeDir: actor.sessionRuntimeDir,
+                    cwd: cmd.cwd,
+                };
+                fileScope.cwd = resolveTriggerLocalPath(cmd.cwd, fileScope);
+                if (!fs.statSync(fileScope.cwd).isDirectory())
+                    throw new Error('command cwd must be a directory');
+                return { ok: true, fullAccess: false, fileScope };
+            }
+            case 'trigger.list': {
+                const agentAid = requireAgent(cmd.agentAid);
+                const actor = await authorizeTrigger(agentAid, 'trigger.list');
+                const scheduler = schedulerFor(agentAid);
+                const definitions = scheduler.list({ all: cmd.all === true }).filter(trigger => ((actor.daemonPrivileged
+                    || !daemonPrivilegedTriggerReason(trigger)
+                    || daemonPrivilegedTriggerReason(trigger) === 'persistent fullaccess Trigger')
+                    && (actor.management
+                        || (trigger.origin?.peerId === actor.origin?.peerId && trigger.origin?.channelKey === actor.origin?.channelKey))));
+                return { ok: true, triggers: scheduler.listItems(definitions) };
+            }
+            case 'trigger.show': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.show', cmd.triggerId);
+                return {
+                    ok: true,
+                    ...schedulerFor(agentAid).show(cmd.triggerId, {
+                        includeScriptPreview: cmd.includeScriptPreview !== false,
+                    }),
+                };
+            }
+            case 'trigger.history': {
+                const agentAid = requireAgent(cmd.agentAid);
+                const limit = cmd.limit === undefined ? 100 : Number(cmd.limit);
+                if (!Number.isInteger(limit) || limit <= 0 || limit > 10_000)
+                    throw new Error('invalid history limit');
+                if (cmd.triggerId !== undefined && (typeof cmd.triggerId !== 'string' || !cmd.triggerId)) {
+                    throw new Error('invalid triggerId');
+                }
+                let actor;
+                if (cmd.triggerId)
+                    await authorizeTrigger(agentAid, 'trigger.history', cmd.triggerId);
+                else
+                    actor = await authorizeTrigger(agentAid, 'trigger.history');
+                if (!cmd.triggerId && !actor?.management) {
+                    throw new Error('triggerId is required for non-management history access');
+                }
+                const scheduler = schedulerFor(agentAid);
+                const events = scheduler.history(cmd.triggerId, limit);
+                if (cmd.triggerId || actor?.daemonPrivileged)
+                    return { ok: true, events };
+                const privilegedIds = new Set(scheduler.list({ all: true })
+                    .filter(trigger => !!daemonPrivilegedTriggerReason(trigger))
+                    .map(trigger => trigger.id));
+                return { ok: true, events: events.filter((event) => !privilegedIds.has(String(event.triggerId ?? ''))) };
+            }
+            case 'trigger.eventCatalog': {
+                const agentAid = requireAgent(cmd.agentAid);
+                const actor = await authorizeTrigger(agentAid, 'trigger.eventCatalog');
+                if (cmd.includeInternal === true && !actor.daemonPrivileged) {
+                    throw new Error('internal Trigger event catalog requires DaemonOwner');
+                }
+                return { ok: true, ...getEventCatalog({ includeInternal: cmd.includeInternal === true }) };
+            }
+            case 'trigger.create': {
+                const rawDefinition = cmd.definition;
+                if (!rawDefinition || typeof rawDefinition !== 'object' || Array.isArray(rawDefinition)) {
+                    throw new Error('trigger definition must be an object');
+                }
+                const agentAid = requireAgent(rawDefinition.agentAid);
+                const actor = await authorizeTrigger(agentAid, 'trigger.create');
+                const materialized = materializeTriggerCreateBaseagent({ ...rawDefinition, origin: actor.origin }, agentAid, dependencies);
+                let definition = normalizeTriggerDefinition(materialized);
+                rejectUnapprovedFullAccessConfiguration(definition, actor);
+                definition = withFullAccessConfigurationProvenance(definition, actor);
+                dependencies.validateTriggerDefinitionForActor(definition, actor);
+                requireAgent(definition.agentAid);
+                dependencies.validateTriggerFeedbackChannels(definition);
+                const trigger = schedulerFor(definition.agentAid).create(definition, cmd.files ?? [], { enable: cmd.enable });
+                if (trigger.execution.permissionMode === 'fullaccess') {
+                    auditFullAccessTriggerConfiguration('fullaccess.trigger.configured', trigger, actor, 'fullaccess Trigger created through IPC');
+                }
+                return { ok: true, trigger };
+            }
+            case 'trigger.update': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                const actor = await authorizeTrigger(agentAid, 'trigger.update', cmd.triggerId);
+                const scheduler = schedulerFor(agentAid);
+                const existing = scheduler.list({ all: true }).find(trigger => trigger.id === cmd.triggerId);
+                if (!existing)
+                    throw new Error(`trigger not found: ${cmd.triggerId}`);
+                const rawPatch = cmd.patch && typeof cmd.patch === 'object' && !Array.isArray(cmd.patch)
+                    ? cmd.patch
+                    : {};
+                const rawScriptFile = rawPatch.scriptFile;
+                if (rawScriptFile !== undefined && rawScriptFile !== true) {
+                    throw new Error('scriptFile must be true');
+                }
+                const patchScriptFile = rawScriptFile === true;
+                const { scriptFile: _scriptFile, ...definitionPatch } = rawPatch;
+                const scriptFileBase64 = cmd.scriptFileBase64;
+                if (patchScriptFile && scriptFileBase64 === undefined) {
+                    throw new Error('--script-file requires scriptFileBase64');
+                }
+                if (!patchScriptFile && scriptFileBase64 !== undefined) {
+                    throw new Error('scriptFileBase64 requires --script-file');
+                }
+                if (scriptFileBase64 !== undefined) {
+                    if (typeof scriptFileBase64 !== 'string') {
+                        throw new Error('scriptFileBase64 must be a base64 string');
+                    }
+                    if (!actor.daemonPrivileged && actor.role !== 'owner') {
+                        throw new Error('updating an Agent-scoped script Trigger requires the current Agent owner');
+                    }
+                    if (existing.execution.type !== 'script' || !existing.execution.script) {
+                        throw new Error('--script-file only applies to script Triggers');
+                    }
+                    decodeTriggerScriptFile(scriptFileBase64);
+                }
+                const currentRevision = definitionRevision(existing);
+                if (cmd.expectedRevision !== undefined && cmd.expectedRevision !== currentRevision) {
+                    throw new Error(`trigger revision conflict: expected ${cmd.expectedRevision}, current ${currentRevision}`);
+                }
+                let definition = Object.keys(definitionPatch).length > 0
+                    ? applyTriggerPatch(existing, definitionPatch, { fromPromptFile: cmd.promptFile === true })
+                    : existing;
+                rejectUnapprovedFullAccessConfiguration(definition, actor);
+                definition = withFullAccessConfigurationProvenance(definition, actor);
+                dependencies.validateTriggerDefinitionForActor(definition, actor);
+                dependencies.validateTriggerFeedbackChannels(definition);
+                const files = scriptFileBase64 !== undefined && existing.execution.script
+                    ? [{
+                            relativePath: splitScriptCommand(existing.execution.script.path).path,
+                            contentBase64: scriptFileBase64,
+                        }]
+                    : [];
+                const trigger = scheduler.update(cmd.triggerId, definition, files);
+                if (trigger.execution.permissionMode === 'fullaccess') {
+                    auditFullAccessTriggerConfiguration('fullaccess.trigger.configured', trigger, actor, existing.execution.permissionMode === 'fullaccess'
+                        ? 'fullaccess Trigger updated through IPC'
+                        : 'Trigger elevated to fullaccess through IPC');
+                }
+                else if (existing.execution.permissionMode === 'fullaccess') {
+                    auditFullAccessTriggerConfiguration('fullaccess.trigger.deescalated', existing, actor, 'Trigger permissionMode changed from fullaccess through IPC');
+                }
+                return { ok: true, trigger: scheduler.listItem(trigger), revision: definitionRevision(trigger) };
+            }
+            case 'trigger.setEnabled': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                if (typeof cmd.enabled !== 'boolean')
+                    throw new Error('missing enabled');
+                const actor = await authorizeTrigger(agentAid, 'trigger.setEnabled', cmd.triggerId);
+                const scheduler = schedulerFor(agentAid);
+                const existing = scheduler.list({ all: true }).find(trigger => trigger.id === cmd.triggerId);
+                if (!existing)
+                    throw new Error(`trigger not found: ${cmd.triggerId}`);
+                if (cmd.enabled && existing.execution.permissionMode === 'fullaccess') {
+                    rejectUnapprovedFullAccessConfiguration(existing, actor);
+                    if (!actor.daemonOwner && !actor.fullAccess) {
+                        throw new Error('enabling a fullaccess Trigger requires a DaemonOwner or fullaccess-run');
+                    }
+                }
+                if (cmd.enabled && existing.execution.permissionMode === 'fullaccess') {
+                    scheduler.update(cmd.triggerId, withFullAccessConfigurationProvenance(existing, actor));
+                }
+                const trigger = scheduler.setEnabled(cmd.triggerId, cmd.enabled);
+                if (cmd.enabled && trigger.execution.permissionMode === 'fullaccess') {
+                    auditFullAccessTriggerConfiguration('fullaccess.trigger.configured', trigger, actor, 'fullaccess Trigger enabled through IPC');
+                }
+                return { ok: true, trigger };
+            }
+            case 'trigger.cancel': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.cancel', cmd.triggerId);
+                const trigger = schedulerFor(agentAid).cancel(cmd.triggerId);
+                return { ok: true, trigger };
+            }
+            case 'trigger.delete': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                const actor = await authorizeTrigger(agentAid, 'trigger.delete', cmd.triggerId);
+                const trigger = schedulerFor(agentAid).delete(cmd.triggerId);
+                if (trigger.execution.permissionMode === 'fullaccess') {
+                    auditFullAccessTriggerConfiguration('fullaccess.trigger.deescalated', trigger, actor, 'fullaccess Trigger deleted through IPC');
+                }
+                return { ok: true, trigger };
+            }
+            case 'trigger.run': {
+                const agentAid = requireAgent(cmd.agentAid);
+                if (!cmd.triggerId)
+                    throw new Error('missing triggerId');
+                await authorizeTrigger(agentAid, 'trigger.run', cmd.triggerId);
+                const result = await schedulerFor(agentAid).run(cmd.triggerId, {
+                    dryRun: cmd.dryRun === true,
+                    ...(cmd.eventPayload !== undefined ? { eventPayload: cmd.eventPayload } : {}),
+                });
+                return {
+                    ok: result.ok,
+                    result,
+                    runId: result.runId,
+                    triggerId: result.triggerId,
+                    status: result.status,
+                    reason: result.reason,
+                    conflictRunId: result.conflictRunId,
+                    error: result.error,
+                    audit: result.audit,
+                };
+            }
+            default:
+                return { ok: false, error: `unknown trigger command: ${cmd.type}` };
+        }
+    };
+}

package/dist/trigger/local-files.js

@@ -0,0 +1,133 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveRoot } from '../paths.js';
+import { classifyProtectedPath, isSameOrDescendant } from '../core/permission/protected-paths.js';
+export const TRIGGER_LOCAL_FILE_LIMIT = 4 * 1024 * 1024;
+export function decodeTriggerScriptFile(contentBase64) {
+    if (typeof contentBase64 !== 'string'
+        || contentBase64.length > 4 * Math.ceil(TRIGGER_LOCAL_FILE_LIMIT / 3)
+        || contentBase64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(contentBase64)) {
+        throw new Error('Trigger file content must be canonical base64 under 4 MiB');
+    }
+    const contents = Buffer.from(contentBase64, 'base64');
+    if (contents.length > TRIGGER_LOCAL_FILE_LIMIT || contents.toString('base64') !== contentBase64) {
+        throw new Error('Trigger file content must be canonical base64 under 4 MiB');
+    }
+    return contents;
+}
+export function resolveTriggerLocalPath(input, scope) {
+    if (!input || /[\0\r\n]/.test(input) || hasUnsafeWindowsPathSyntax(input))
+        throw new Error('invalid Trigger input path');
+    const normalizedInput = input.replace(/\\/g, '/');
+    if (normalizedInput.split('/').includes('..'))
+        throw new Error('Trigger input path cannot traverse parent directories');
+    const lexical = path.resolve(scope?.cwd ?? process.cwd(), input);
+    if (!scope)
+        return fs.realpathSync.native(lexical);
+    const project = fs.realpathSync.native(scope.projectPath);
+    const runtime = scope.sessionRuntimeDir
+        ? fs.realpathSync.native(scope.sessionRuntimeDir)
+        : undefined;
+    assertSessionRuntimeScope(lexical, runtime);
+    const inProjectLexically = isSameOrDescendant(lexical, project);
+    const inSessionTempLexically = !!runtime && isSameOrDescendant(lexical, runtime);
+    if (!inProjectLexically && !inSessionTempLexically) {
+        throw new Error('Trigger input must be inside the current project or session TMPDIR');
+    }
+    let current = lexical;
+    while (true) {
+        const stat = fs.lstatSync(current);
+        if (stat.isSymbolicLink()) {
+            throw new Error('Trigger input must not traverse a symbolic link or junction');
+        }
+        if (current === project || current === runtime)
+            break;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    const resolved = fs.realpathSync.native(lexical);
+    assertSessionRuntimeScope(resolved, runtime);
+    const inProject = isSameOrDescendant(lexical, project) && isSameOrDescendant(resolved, project);
+    const inSessionTemp = !!runtime
+        && isSameOrDescendant(lexical, runtime)
+        && isSameOrDescendant(resolved, runtime);
+    if (!inProject && !inSessionTemp) {
+        throw new Error('Trigger input must be inside the current project or session TMPDIR');
+    }
+    const root = resolveRoot();
+    const lexicalClass = classifyProtectedPath(lexical, { root, selfAid: scope.selfAid });
+    const resolvedClass = classifyProtectedPath(resolved, { root, selfAid: scope.selfAid });
+    if (isProtectedTriggerInputClass(lexicalClass) || isProtectedTriggerInputClass(resolvedClass)) {
+        throw new Error('Trigger input references a protected path');
+    }
+    return resolved;
+}
+function isProtectedTriggerInputClass(value) {
+    return value === 'h-file' || value === 'h-directory' || value === 'l-path' || value === 'unknown';
+}
+function hasUnsafeWindowsPathSyntax(input) {
+    if (process.platform !== 'win32')
+        return false;
+    const normalized = input.replace(/\\/g, '/');
+    const withoutDrive = /^[A-Za-z]:\//.test(normalized) ? normalized.slice(2) : normalized;
+    return withoutDrive.includes(':') || withoutDrive.split('/').some(segment => (/[. ]$/.test(segment) && segment !== '.' && segment !== '..') || /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(segment));
+}
+function assertSessionRuntimeScope(candidate, runtime) {
+    if (!runtime)
+        return;
+    const parent = path.dirname(runtime);
+    if (!isSameOrDescendant(candidate, parent))
+        return;
+    const firstSegment = path.relative(parent, candidate).split(path.sep)[0];
+    if (/^ec-session-[a-f0-9]{24}$/i.test(firstSegment)
+        && !isSameOrDescendant(candidate, runtime)) {
+        throw new Error('Trigger input must not reference another session TMPDIR');
+    }
+}
+export function readTriggerLocalFile(input, scope) {
+    const resolved = resolveTriggerLocalPath(input, scope);
+    const expected = fs.lstatSync(resolved);
+    if (!expected.isFile())
+        throw new Error('Trigger input must be a regular file');
+    if (scope && expected.nlink !== 1)
+        throw new Error('Trigger input must not be hard-linked');
+    const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+    const descriptor = fs.openSync(resolved, fs.constants.O_RDONLY | noFollow);
+    try {
+        const opened = fs.fstatSync(descriptor);
+        if (!opened.isFile() || opened.dev !== expected.dev || opened.ino !== expected.ino
+            || (scope && opened.nlink !== 1)
+            || resolveTriggerLocalPath(input, scope) !== resolved) {
+            throw new Error('Trigger input changed during validation');
+        }
+        if (opened.size > TRIGGER_LOCAL_FILE_LIMIT)
+            throw new Error('Trigger input exceeds the 4 MiB limit');
+        const openedMtime = opened.mtimeMs;
+        const openedCtime = opened.ctimeMs;
+        const buffer = Buffer.alloc(Math.min(opened.size + 1, TRIGGER_LOCAL_FILE_LIMIT + 1));
+        let length = 0;
+        while (length < buffer.length) {
+            const count = fs.readSync(descriptor, buffer, length, buffer.length - length, length);
+            if (!count)
+                break;
+            length += count;
+        }
+        const afterRead = fs.fstatSync(descriptor);
+        const afterPath = fs.lstatSync(resolved);
+        if (length !== opened.size || afterRead.size !== opened.size
+            || afterRead.mtimeMs !== openedMtime || afterRead.ctimeMs !== openedCtime
+            || afterPath.dev !== opened.dev || afterPath.ino !== opened.ino
+            || !afterPath.isFile() || afterPath.isSymbolicLink()
+            || afterPath.size !== opened.size || afterPath.mtimeMs !== openedMtime || afterPath.ctimeMs !== openedCtime
+            || (scope && (afterRead.nlink !== 1 || afterPath.nlink !== 1))
+            || resolveTriggerLocalPath(input, scope) !== resolved) {
+            throw new Error('Trigger input changed during reading');
+        }
+        return buffer.subarray(0, length);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}