@rynx-ai/daemon 0.1.10 → 0.1.11-beta.10

package/dist/plugin-host-rpc.js

@@ -1,9 +1,12 @@
 import { createHash, randomUUID } from "node:crypto";
-import { AgentRuntimeError, agentSpecSchema, SteerController, } from "@rynx-ai/core";
+import { realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { AgentRuntimeError, agentSpecSchema, resolvedExecutionSnapshotSchema, sessionWorkspaceSnapshotSchema, SteerController, } from "@rynx-ai/core";
 import { PLUGIN_HOST_MAX_ACTIVE_RUNS, } from "@rynx-ai/plugin-sdk";
 import { PluginRunnerError } from "@rynx-ai/plugin-runner";
-import { ensurePluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
+import { ensurePluginSessionLaunch, replayPluginSessionLaunch, SessionLaunchOperationConflictError, SessionLaunchOperationTargetDeletedError, } from "./session-launch-operations.js";
 import { createControlLink } from "./control-link-store.js";
+import { issueSessionPortalTicket } from "./session-portal-grant-store.js";
 const MAX_MESSAGE_LENGTH = 1_000_000;
 /** Leaves ample room for the RPC envelope below the runner's 1 MiB line cap. */
 export const MAX_PLUGIN_HOST_EVENT_BYTES = 512 * 1024;
@@ -11,31 +14,8 @@ const MAX_PLUGIN_RUN_FINAL_RESPONSE_BYTES = 64 * 1024;
 const MAX_DELTA_CHUNK_CODE_UNITS = 64 * 1024;
 const SESSION_INTERACTION_RESOLUTION_MAX_BYTES = 128 * 1024;
 const AGENT_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
-const METHOD_CAPABILITY = {
-    "installation.proof.sign": "installation.proof",
-    "agent.catalog.list": "agent.catalog.read",
-    "agent.catalog.get": "agent.catalog.read",
-    "agent.execution.resolve": "agent.catalog.read",
-    "session.ensure": "session.provision",
-    "session.run": "conversation.run",
-    "session.steer": "conversation.run",
-    "session.interrupt": "session.cancel",
-    "session.interaction.resolve": "conversation.run",
-    "session.models": "runtime.catalog.read",
-    "session.binding.get": "session.binding.read",
-    "session.binding.list": "session.binding.read",
-    "session.binding.find": "session.binding.read",
-    "session.goal.get": "session.goal.read",
-    "session.goal.set": "session.goal.write",
-    "session.goal.clear": "session.goal.write",
-    "session.fork": "session.fork",
-    "session.meta.get": "session.meta.read",
-    "session.meta.list": "session.meta.read",
-    "session.meta.setTitle": "session.meta.title.write",
-    "control.link.issue": "control-link.issue",
-};
 /**
- * One authenticated plugin's capability-gated Host RPC surface.
+ * One authenticated plugin's Host RPC surface.
  *
  * This adapter is deliberately the only place that maps public string methods
  * to trusted runtime objects. The runner receives neither this class nor its
@@ -43,43 +23,53 @@ const METHOD_CAPABILITY = {
  */
 export class PluginHostRpc {
     pluginId;
+    principalId;
     daemonInstanceId;
-    grants;
+    productVersion;
+    cliVersion;
     services;
+    managedWorkspaceRoot;
     emit;
+    disposeForceAfterMs;
     activeRuns = new Map();
     activeSessionRuns = new Map();
     activeRunsByOperation = new Map();
     disposed = false;
+    disposePromise;
     constructor(options) {
         this.pluginId = requiredString(options.pluginId, "pluginId", 64);
+        this.principalId = requiredString(options.principalId ?? options.pluginId, "principalId", 160);
         this.daemonInstanceId = requiredString(options.daemonInstanceId, "daemonInstanceId", 128);
-        this.grants = new Set(options.grants);
+        this.productVersion = requiredString(options.productVersion, "productVersion", 128);
+        this.cliVersion = requiredString(options.cliVersion, "cliVersion", 128);
         this.services = options.services;
+        this.managedWorkspaceRoot = options.managedWorkspaceRoot
+            ? path.resolve(options.managedWorkspaceRoot)
+            : undefined;
         this.emit = options.emit;
+        this.disposeForceAfterMs = options.disposeForceAfterMs ?? 10_000;
     }
-    async call(method, params) {
+    async call(method, params, signal) {
         if (this.disposed)
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
+        throwIfHostCallAborted(signal);
         if (method === "host.info") {
             return {
                 pluginId: this.pluginId,
                 installationId: this.services.installationId,
                 daemonInstanceId: this.daemonInstanceId,
+                productVersion: this.productVersion,
+                cliVersion: this.cliVersion,
                 installationProof: {
                     algorithm: this.services.installationProof.algorithm,
                     publicKey: this.services.installationProof.publicKey,
                 },
                 protocolVersion: 1,
-                grants: [...this.grants],
+                ...(this.services.sessionPortal
+                    ? { sessionPortal: { ...this.services.sessionPortal } }
+                    : {}),
             };
         }
-        const capability = METHOD_CAPABILITY[method];
-        if (!capability)
-            throw new PluginHostCallError("METHOD_NOT_FOUND", `unknown host method: ${method}`);
-        if (!this.grants.has(capability)) {
-            throw new PluginHostCallError("CAPABILITY_DENIED", `host method ${method} requires capability ${capability}`);
-        }
         try {
             switch (method) {
                 case "installation.proof.sign": {
@@ -87,7 +77,7 @@ export class PluginHostRpc {
                     return {
                         algorithm: this.services.installationProof.algorithm,
                         publicKey: this.services.installationProof.publicKey,
-                        signature: this.services.installationProof.sign(this.pluginId, challenge),
+                        signature: this.services.installationProof.sign(this.principalId, challenge),
                     };
                 }
                 case "agent.catalog.list":
@@ -97,9 +87,9 @@ export class PluginHostRpc {
                 case "agent.execution.resolve":
                     return await this.resolveAgentExecution(params);
                 case "session.ensure":
-                    return this.ensureSession(params);
+                    return await this.ensureSession(params);
                 case "session.run":
-                    return await this.runSession(params);
+                    return await this.runSession(params, signal);
                 case "session.steer":
                     return this.steerSession(params);
                 case "session.interrupt":
@@ -133,6 +123,16 @@ export class PluginHostRpc {
                     return this.setSessionTitle(params);
                 case "control.link.issue":
                     return this.issueControlLink(params);
+                case "session.portal.plugin.issue": {
+                    const access = requiredSessionPortalAccess(params);
+                    return this.issueSessionPortalLink("plugin_sessions", access);
+                }
+                case "session.portal.session.issue": {
+                    const input = record(params);
+                    const sessionId = requiredSessionId(input);
+                    this.ownedSession(sessionId);
+                    return this.issueSessionPortalLink("single_session", requiredSessionPortalAccess(input), sessionId);
+                }
                 default:
                     throw new PluginHostCallError("METHOD_NOT_FOUND", `unknown host method: ${method}`);
             }
@@ -142,44 +142,174 @@ export class PluginHostRpc {
         }
     }
     async dispose() {
-        if (this.disposed)
-            return;
+        if (this.disposePromise)
+            return this.disposePromise;
         this.disposed = true;
         const runs = [...this.activeRuns.values()];
-        this.activeRuns.clear();
-        this.activeSessionRuns.clear();
-        this.activeRunsByOperation.clear();
-        for (const run of runs) {
-            run.interruptRequested = true;
-            if (run.interruptResult && await run.interruptResult.catch(() => false))
-                continue;
-            if (this.services.interruptSession) {
-                await this.services.interruptSession(run.sessionId).catch(() => false);
-            }
-            else {
-                run.abort.abort();
+        this.disposePromise = (async () => {
+            const stopped = await Promise.allSettled(runs.map(async (run) => {
+                if (this.activeRuns.get(run.runId) !== run)
+                    return;
+                run.interruptRequested = true;
+                const graceful = run.interruptResult ?? (this.services.interruptSession
+                    ? Promise.resolve().then(() => this.services.interruptSession(run.sessionId))
+                    : Promise.resolve().then(() => {
+                        run.abort.abort();
+                        return false;
+                    }));
+                const authoritative = forceStoppedInterrupt(graceful, this.disposeForceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
+                run.interruptResult = authoritative;
+                if (!(await authoritative)) {
+                    throw new Error(`could not prove Session ${run.sessionId} stopped`);
+                }
+                this.releaseRun(run);
+            }));
+            const failures = stopped
+                .filter((result) => result.status === "rejected")
+                .map((result) => result.reason);
+            if (failures.length > 0) {
+                throw new AggregateError(failures, "plugin Host could not stop every active run");
             }
-        }
+        })();
+        return this.disposePromise;
+    }
+    async ensureSession(params) {
+        return this.withAdmission(() => this.ensureSessionAdmitted(params));
     }
-    ensureSession(params) {
+    async ensureSessionAdmitted(params) {
         const input = record(params);
         const scopeId = requiredString(input.scopeId, "scopeId", 512);
         const operationId = requiredString(input.operationId, "operationId", 512);
-        const session = sessionLaunchMeta(input.session);
-        const requestHash = hashCanonicalJson(session);
-        return ensurePluginSessionLaunch({
-            pluginId: this.pluginId,
+        const parsedSelection = sessionLaunchSelection(input.session);
+        if (parsedSelection.managedCwd && !this.managedWorkspaceRoot) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        const rawRequestHash = hashCanonicalJson(parsedSelection);
+        const replay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash: rawRequestHash,
+            allowRequestHashMismatch: true,
+        });
+        if (replay)
+            return this.sessionEnsureResult(replay);
+        const selection = parsedSelection.managedCwd
+            ? {
+                ...parsedSelection,
+                managedCwd: await this.resolveManagedWorkspace(parsedSelection.managedCwd),
+            }
+            : parsedSelection.workspace
+                ? {
+                    ...parsedSelection,
+                    workspace: await this.resolveWorkspaceSnapshot(parsedSelection.workspace),
+                }
+                : parsedSelection;
+        const requestHash = hashCanonicalJson(selection);
+        const canonicalReplay = replayPluginSessionLaunch({
+            pluginId: this.principalId,
             scopeId,
             operationId,
             requestHash,
-            session,
         });
+        if (canonicalReplay)
+            return this.sessionEnsureResult(canonicalReplay);
+        const resolved = await this.services.sessionLaunch.resolve(selection);
+        const ensured = ensurePluginSessionLaunch({
+            pluginId: this.principalId,
+            scopeId,
+            operationId,
+            requestHash,
+            rawRequestHash,
+            session: {
+                workspace: sessionWorkspaceSnapshotSchema.parse(resolved.workspace),
+                execution: resolvedExecutionSnapshotSchema.parse(resolved.execution),
+                ...(selection.title ? { title: selection.title } : {}),
+            },
+        });
+        return this.sessionEnsureResult(ensured);
+    }
+    async resolveManagedWorkspace(directory) {
+        const root = this.managedWorkspaceRoot;
+        if (!root) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd is reserved for the built-in Workspace plugin");
+        }
+        if (!path.isAbsolute(directory)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be absolute");
+        }
+        let canonicalRoot;
+        let canonicalDirectory;
+        try {
+            [canonicalRoot, canonicalDirectory] = await Promise.all([
+                realpath(root),
+                realpath(directory),
+            ]);
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd must be an existing plugin-managed directory");
+        }
+        const relative = path.relative(canonicalRoot, canonicalDirectory);
+        if (relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative)) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.managedCwd escapes the plugin-managed workspace root");
+        }
+        return canonicalDirectory;
+    }
+    async resolveWorkspaceSnapshot(workspace) {
+        const directories = [workspace.cwd, ...workspace.allowedDirs];
+        if (directories.some((directory) => !path.isAbsolute(directory))) {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be absolute");
+        }
+        let canonical;
+        try {
+            canonical = await Promise.all(directories.map(async (directory) => {
+                const resolved = await realpath(directory);
+                if (!(await stat(resolved)).isDirectory()) {
+                    throw new Error("not a directory");
+                }
+                return resolved;
+            }));
+        }
+        catch {
+            throw new PluginHostCallError("INVALID_PARAMS", "session.workspace paths must be existing directories");
+        }
+        const parsed = sessionWorkspaceSnapshotSchema.safeParse({
+            cwd: canonical[0],
+            allowedDirs: canonical.slice(1),
+        });
+        if (!parsed.success) {
+            throw new PluginHostCallError("INVALID_PARAMS", `invalid session.workspace: ${parsed.error.issues[0]?.message ?? "invalid snapshot"}`);
+        }
+        return parsed.data;
+    }
+    sessionEnsureResult(result) {
+        const session = this.ownedSession(result.sessionId);
+        return {
+            ...result,
+            execution: {
+                provider: session.execution.provider,
+                model: session.execution.model,
+                reasoningEffort: session.execution.reasoningEffort,
+            },
+        };
+    }
+    async runSession(params, signal) {
+        return this.withAdmission(() => this.runSessionAdmitted(params, signal));
     }
-    async runSession(params) {
+    async runSessionAdmitted(params, signal) {
         const input = record(params);
         const sessionId = requiredSessionId(input);
         const operationId = optionalString(input.operationId, "operationId", 512);
-        const session = this.ownedSession(sessionId);
+        const modelProvided = input.model !== undefined;
+        const requestedModel = input.model === null || input.model === ""
+            ? null
+            : optionalString(input.model, "model", 256);
+        const reasoningEffortProvided = input.reasoningEffort !== undefined;
+        const requestedReasoningEffort = input.reasoningEffort === null || input.reasoningEffort === ""
+            ? null
+            : optionalString(input.reasoningEffort, "reasoningEffort", 64);
+        let session = this.ownedSession(sessionId);
         if (operationId && this.activeRunsByOperation.has(operationId)) {
             throw new PluginHostCallError("RUN_ALREADY_ACTIVE", `operation already has an active run: ${operationId}`, true);
         }
@@ -190,7 +320,26 @@ export class PluginHostRpc {
             throw new PluginHostCallError("RUN_LIMIT", "plugin has too many active session runs", true);
         }
         const message = requiredText(input.message, "message", MAX_MESSAGE_LENGTH);
+        const nextModel = modelProvided ? requestedModel ?? null : session.execution.model;
+        const nextReasoningEffort = reasoningEffortProvided
+            ? requestedReasoningEffort ?? null
+            : session.execution.reasoningEffort;
+        if (nextModel !== session.execution.model ||
+            nextReasoningEffort !== session.execution.reasoningEffort) {
+            await this.services.sessionExecution.update({
+                sessionId,
+                model: nextModel,
+                reasoningEffort: nextReasoningEffort,
+            });
+            session = this.ownedSession(sessionId);
+        }
         const abort = new AbortController();
+        const cancel = () => abort.abort(signal?.reason);
+        if (signal?.aborted) {
+            cancel();
+            throwIfHostCallAborted(signal);
+        }
+        signal?.addEventListener("abort", cancel, { once: true });
         const steer = new SteerController();
         const runId = randomUUID();
         const run = {
@@ -210,23 +359,23 @@ export class PluginHostRpc {
             started = await this.services.conversationRuntime.runLive({
                 message,
                 threadId: sessionId,
-                provider: optionalRuntimeValue(input.provider),
-                model: optionalString(input.model, "model", 256) ?? session.model,
-                reasoningEffort: optionalString(input.reasoningEffort, "reasoningEffort", 128) ?? session.reasoningEffort,
-                cwd: optionalString(input.cwd, "cwd", 16_384),
-                agentName: optionalAgentId(input.agent, "agent") ?? session.agent,
-                agentSpec: session.config,
+                workspace: session.workspace,
+                execution: session.execution,
                 signal: abort.signal,
                 steer,
-                developerInstructions: optionalString(input.developerInstructions, "developerInstructions", 200_000),
             });
         }
         catch (error) {
             this.releaseRun(run);
             throw error;
         }
-        if (this.disposed || this.activeRuns.get(runId) !== run) {
+        finally {
+            signal?.removeEventListener("abort", cancel);
+        }
+        if (signal?.aborted || this.disposed || this.activeRuns.get(runId) !== run) {
+            abort.abort(signal?.reason);
             this.releaseRun(run);
+            throwIfHostCallAborted(signal);
             throw new PluginHostCallError("HOST_CLOSED", "plugin host is closed");
         }
         // Let the RPC transport write the request response before stream events are
@@ -338,6 +487,10 @@ export class PluginHostRpc {
     async interruptRun(params) {
         const input = record(params);
         const run = this.activeRunByIdentity(input);
+        const forceAfterMs = optionalPositiveNumber(input.forceAfterMs, "forceAfterMs");
+        if (forceAfterMs !== undefined && forceAfterMs > 30_000) {
+            throw new PluginHostCallError("INVALID_PARAMS", "forceAfterMs must not exceed 30000");
+        }
         if (run.interruptResult) {
             return { interrupted: await run.interruptResult };
         }
@@ -345,7 +498,7 @@ export class PluginHostRpc {
         // the authoritative stop is pending wait for its result: true suppresses
         // them, while false/error lets genuine native progress/terminal continue.
         run.interruptRequested = true;
-        const interruptResult = this.services.interruptSession
+        const graceful = this.services.interruptSession
             // ConversationRuntime wires AbortSignal to this same native operation.
             // Invoke it directly once so this boolean is the authoritative result;
             // aborting first would trigger a duplicate, unobserved interrupt.
@@ -356,6 +509,9 @@ export class PluginHostRpc {
                 // effort and cannot prove that native execution stopped.
                 return false;
             });
+        const interruptResult = forceAfterMs === undefined
+            ? graceful
+            : forceStoppedInterrupt(graceful, forceAfterMs, () => this.services.terminateSession?.(run.sessionId) ?? Promise.resolve(false));
         run.interruptResult = interruptResult;
         try {
             const interrupted = await interruptResult;
@@ -437,12 +593,40 @@ export class PluginHostRpc {
         return await resolve(sessionId, interactionId, resolution);
     }
     async forkSession(params) {
+        return this.withAdmission(() => this.forkSessionAdmitted(params));
+    }
+    async forkSessionAdmitted(params) {
         const input = record(params);
-        const fromSessionId = requiredString(input.fromSessionId, "fromSessionId", 512);
-        const toSessionId = requiredString(input.toSessionId, "toSessionId", 512);
-        this.ownedSession(fromSessionId);
-        this.ownedSession(toSessionId);
-        return await this.services.capabilities.forkSession(fromSessionId, toSessionId);
+        const sourceSessionId = requiredString(input.sourceSessionId, "sourceSessionId", 512);
+        const operationId = requiredString(input.operationId, "operationId", 512);
+        const title = optionalString(input.title, "title", 1_000);
+        this.ownedSession(sourceSessionId);
+        if (!this.services.sessionFork) {
+            throw new PluginHostCallError("HOST_CALL_FAILED", "Session fork is unavailable");
+        }
+        return await this.services.sessionFork({
+            sourceSessionId,
+            operationId: `${this.principalId}:${operationId}`,
+            ...(title ? { title } : {}),
+        });
+    }
+    reserveAdmission() {
+        const reservation = this.services.admissionReserve?.();
+        if (reservation)
+            return reservation;
+        if (!this.services.admissionReserve && this.services.admissionOpen?.() !== false) {
+            return { release() { } };
+        }
+        throw new PluginHostCallError("HOST_CALL_FAILED", "daemon maintenance is in progress", true);
+    }
+    async withAdmission(operation) {
+        const reservation = this.reserveAdmission();
+        try {
+            return await operation();
+        }
+        finally {
+            reservation.release();
+        }
     }
     setSessionTitle(params) {
         const input = record(params);
@@ -466,11 +650,22 @@ export class PluginHostRpc {
         this.ownedSession(sessionId);
         const ttlSeconds = optionalPositiveNumber(input.ttlSeconds, "ttlSeconds");
         return createControlLink({
-            pluginId: this.pluginId,
+            pluginId: this.principalId,
             sessionId,
             ...(ttlSeconds === undefined ? {} : { ttlMs: ttlSeconds * 1_000 }),
         });
     }
+    issueSessionPortalLink(scope, access, sessionId) {
+        if (!this.services.sessionPortal) {
+            throw new PluginHostCallError("HOST_CALL_FAILED", "the Session Portal is not configured");
+        }
+        return issueSessionPortalTicket({
+            pluginId: this.principalId,
+            scope,
+            access,
+            ...(sessionId ? { sessionId } : {}),
+        });
+    }
     ownedSession(sessionId) {
         const session = this.services.sessionRegistry.get(sessionId);
         if (!session || !this.isOwned(session)) {
@@ -479,9 +674,24 @@ export class PluginHostRpc {
         return session;
     }
     isOwned(session) {
-        return session.source === `plugin:${this.pluginId}`;
+        const seen = new Set();
+        let current = session;
+        while (current && !seen.has(current.id)) {
+            if (current.source === `plugin:${this.principalId}`)
+                return true;
+            seen.add(current.id);
+            current = current.forkedFromSessionId
+                ? this.services.sessionRegistry.get(current.forkedFromSessionId)
+                : undefined;
+        }
+        return false;
     }
 }
+function throwIfHostCallAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw new PluginHostCallError("REQUEST_CANCELLED", "plugin host request was cancelled");
+}
 export class PluginHostCallError extends PluginRunnerError {
     retryable;
     data;
@@ -512,22 +722,53 @@ function toHostCallError(error) {
     }
     return new PluginHostCallError("HOST_CALL_FAILED", error instanceof Error ? error.message : String(error));
 }
-function sessionLaunchMeta(value) {
+function sessionLaunchSelection(value) {
     const input = record(value);
     assertJsonValue(input, "session");
+    const projectId = optionalString(input.projectId, "session.projectId", 512);
+    const managedCwd = optionalString(input.managedCwd, "session.managedCwd", 16_384);
+    const workspace = optionalSessionWorkspace(input.workspace);
     const agent = optionalAgentId(input.agent, "session.agent");
     const config = input.config === undefined ? undefined : agentSpecSchema.parse(input.config);
-    const model = optionalString(input.model, "session.model", 256);
+    const provider = optionalRuntimeValue(input.provider);
+    const modelProvided = input.model !== undefined;
+    const model = input.model === null || input.model === ""
+        ? null
+        : optionalString(input.model, "session.model", 256);
     const reasoningEffort = optionalString(input.reasoningEffort, "session.reasoningEffort", 128);
     const title = optionalString(input.title, "session.title", 1_000);
+    if (Number(Boolean(projectId)) + Number(Boolean(managedCwd)) + Number(Boolean(workspace)) > 1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.projectId, session.managedCwd, and session.workspace are mutually exclusive");
+    }
+    if (Number(Boolean(agent)) +
+        Number(Boolean(config)) +
+        Number(Boolean(provider)) >
+        1) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.agent, session.config, and session.provider are mutually exclusive");
+    }
     return {
+        ...(projectId ? { projectId } : {}),
+        ...(managedCwd ? { managedCwd } : {}),
+        ...(workspace ? { workspace } : {}),
         ...(agent ? { agent } : {}),
         ...(config ? { config } : {}),
-        ...(model ? { model } : {}),
+        ...(provider ? { provider } : {}),
+        ...(modelProvided ? { model: model ?? null } : {}),
         ...(reasoningEffort ? { reasoningEffort } : {}),
         ...(title ? { title } : {}),
     };
 }
+function optionalSessionWorkspace(value) {
+    if (value === undefined)
+        return undefined;
+    const input = record(value);
+    const cwd = requiredPathString(input.cwd, "session.workspace.cwd", 16_384);
+    if (!Array.isArray(input.allowedDirs) || input.allowedDirs.length === 0) {
+        throw new PluginHostCallError("INVALID_PARAMS", "session.workspace.allowedDirs must be a non-empty string array");
+    }
+    const allowedDirs = input.allowedDirs.map((directory, index) => requiredPathString(directory, `session.workspace.allowedDirs[${index}]`, 16_384));
+    return { cwd, allowedDirs };
+}
 function sessionExecutionSnapshot(value) {
     const input = record(value);
     const runtime = optionalRuntimeValue(input.runtime);
@@ -544,6 +785,12 @@ function sessionExecutionSnapshot(value) {
 function requiredSessionId(params) {
     return requiredString(record(params).sessionId, "sessionId", 512);
 }
+function requiredSessionPortalAccess(params) {
+    const access = record(params).access;
+    if (access === "read_only" || access === "read_write")
+        return access;
+    throw new PluginHostCallError("INVALID_PARAMS", "access must be read_only or read_write");
+}
 function sessionInteractionResolution(value) {
     const input = record(value);
     const keys = Object.keys(input);
@@ -608,6 +855,15 @@ function requiredString(value, label, maxLength) {
     }
     return value.trim();
 }
+function requiredPathString(value, label, maxLength) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
+    }
+    if (value.length > maxLength) {
+        throw new PluginHostCallError("INVALID_PARAMS", `${label} is too long`);
+    }
+    return value;
+}
 function requiredText(value, label, maxLength) {
     if (typeof value !== "string" || !value.trim()) {
         throw new PluginHostCallError("INVALID_PARAMS", `${label} is required`);
@@ -648,6 +904,23 @@ function optionalPositiveNumber(value, label) {
     }
     return value;
 }
+async function forceStoppedInterrupt(graceful, forceAfterMs, terminate) {
+    let timer;
+    const graceExpired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), forceAfterMs);
+        timer.unref?.();
+    });
+    try {
+        if (await Promise.race([graceful.catch(() => false), graceExpired])) {
+            return true;
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+    return terminate();
+}
 function assertJsonValue(value, label, seen = new Set()) {
     if (value === null || typeof value === "string" || typeof value === "boolean")
         return;