@agent-vm/managed-vm 0.0.115

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Shravan Sunder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,290 @@
+//#region src/managed-vm-contracts.d.ts
+/** A command executed in the guest. */
+type ManagedVmExecCommand = string | readonly string[];
+type ManagedVmExecStreamMode = {
+  readonly kind: 'discard';
+} | {
+  readonly kind: 'pipe';
+};
+/**
+ * Explicit bounded streaming policy. Omitting this group preserves the
+ * backend's buffered execution behavior for existing non-streaming callers.
+ */
+interface ManagedVmExecStreamingOptions {
+  readonly stderr: ManagedVmExecStreamMode;
+  readonly stdout: ManagedVmExecStreamMode;
+  readonly windowBytes: number;
+}
+interface ManagedVmExecOptions {
+  readonly argv?: readonly string[];
+  readonly cwd?: string;
+  readonly env?: readonly string[] | Readonly<Record<string, string>>;
+  readonly output?: ManagedVmExecStreamingOptions;
+  readonly pty?: boolean;
+  readonly signal?: AbortSignal;
+  readonly stdin?: string | Uint8Array | AsyncIterable<Uint8Array>;
+}
+interface ManagedVmExecResult {
+  readonly exitCode: number;
+  readonly ok: boolean;
+  readonly signal?: number;
+  readonly stderr: string;
+  readonly stderrBuffer: Uint8Array;
+  readonly stdout: string;
+  readonly stdoutBuffer: Uint8Array;
+  json<TValue>(): TValue;
+  lines(): readonly string[];
+  toString(): string;
+}
+/**
+ * A guest execution is awaitable and may also stream decoded output. The
+ * contract deliberately excludes backend process handles and Node streams.
+ */
+interface ManagedVmExecProcess extends PromiseLike<ManagedVmExecResult>, AsyncIterable<string> {
+  catch<TResult = never>(onRejected?: (reason: Error) => TResult | PromiseLike<TResult>): Promise<ManagedVmExecResult | TResult>;
+  end(): void;
+  finally(onFinally?: () => void): Promise<ManagedVmExecResult>;
+  lines(): AsyncIterable<string>;
+  output(): AsyncIterable<ManagedVmExecOutputChunk>;
+  readonly result: Promise<ManagedVmExecResult>;
+  resize(rows: number, columns: number): void;
+  write(data: string | Uint8Array): void;
+}
+interface ManagedVmExecOutputChunk {
+  readonly data: Uint8Array;
+  readonly stream: 'stderr' | 'stdout';
+  readonly text: string;
+}
+interface ManagedVmSshServerHostKey {
+  readonly algorithm: 'ssh-ed25519';
+  readonly publicKeyBase64: string;
+}
+interface ManagedVmAccessHandle {
+  close(): Promise<void>;
+  readonly host: string;
+  readonly port: number;
+  readonly url?: string;
+}
+interface ManagedVmSshAccess extends ManagedVmAccessHandle {
+  readonly command: string;
+  readonly identityFile: string;
+  readonly serverHostKey: ManagedVmSshServerHostKey;
+  readonly user: string;
+}
+interface ManagedVmEnableSshOptions {
+  readonly listenHost?: string;
+  readonly listenPort?: number;
+  readonly user?: string;
+}
+interface ManagedVmIngressOptions {
+  readonly allowWebSockets?: boolean;
+  readonly listenHost?: string;
+  readonly bufferResponseBody?: boolean;
+  readonly listenPort?: number;
+  readonly maxBufferedResponseBodyBytes?: number;
+  readonly upstreamHeaderTimeoutMs?: number;
+  readonly upstreamResponseTimeoutMs?: number;
+}
+interface ManagedVmIngressRoute {
+  readonly port: number;
+  readonly prefix: string;
+  readonly stripPrefix: boolean;
+}
+interface ManagedVmResources {
+  readonly cpuCount: number;
+  readonly memory: string;
+}
+type ManagedVmRootfsMode = 'readonly' | 'memory' | 'cow';
+interface ManagedVmCanonicalDirectoryIdentity {
+  /** Canonical path is descriptive identity; it is never a mount authority. */
+  readonly canonicalPath: string;
+  readonly device: number;
+  readonly inode: number;
+}
+type OwnedHostDirectoryState = 'acquired' | 'adapter-owned' | 'closed';
+/**
+ * Single-use host-directory authority. Passing this object to createManagedVm
+ * authorizes the provider to call consume exactly once. It exposes no native
+ * handle, file descriptor, or raw-path fallback.
+ */
+interface OwnedHostDirectory {
+  close(): void;
+  consume(): OwnedHostDirectoryTransfer;
+  readonly identity: ManagedVmCanonicalDirectoryIdentity;
+  readonly state: OwnedHostDirectoryState;
+}
+/** Ownership retained by the provider after successful consumption. */
+interface OwnedHostDirectoryTransfer {
+  close(): void;
+  readonly identity: ManagedVmCanonicalDirectoryIdentity;
+  readonly state: 'adapter-owned' | 'closed';
+}
+type ManagedVmFilteredWorkspaceVisibility = {
+  readonly kind: 'whole-root-writable';
+} | {
+  readonly kind: 'positive-paths';
+  readonly visiblePaths: readonly string[];
+  readonly writablePaths: readonly string[];
+};
+interface ManagedVmFilteredWorkspaceReadonlyInput {
+  readonly destinationRelativePath: string;
+  readonly sourceRelativePath: string;
+}
+/** Controller-authored policy over one owned canonical workspace root. */
+interface ManagedVmFilteredWorkspacePolicy {
+  readonly hiddenPaths: readonly string[];
+  readonly readonlyInputs: readonly ManagedVmFilteredWorkspaceReadonlyInput[];
+  readonly temporaryPaths: readonly string[];
+  readonly visibility: ManagedVmFilteredWorkspaceVisibility;
+}
+type ManagedVmMount = {
+  readonly access: 'read-only' | 'read-write';
+  readonly hostPath: string;
+  readonly kind: 'host-directory';
+} | {
+  readonly access: 'read-only' | 'read-write';
+  readonly directory: OwnedHostDirectory;
+  readonly kind: 'owned-host-directory';
+} | {
+  readonly directory: OwnedHostDirectory;
+  readonly kind: 'owned-filtered-workspace';
+  readonly policy: ManagedVmFilteredWorkspacePolicy;
+} | {
+  readonly kind: 'memory';
+} | {
+  readonly deny: readonly string[];
+  readonly hostPath: string;
+  readonly kind: 'shadow';
+  readonly temporaryFilesystems: readonly string[];
+};
+interface ManagedVmMediatedSecretDescriptor {
+  readonly allowedHosts: readonly string[];
+  readonly environmentVariable: string;
+  /** Opaque, non-secret token used to represent the mediated value inside the guest. */
+  readonly guestPlaceholder?: string;
+  /**
+   * Resolved only at the trusted host/provider boundary. The provider must use
+   * this value solely for outbound HTTP mediation and must never inject the raw
+   * value into the guest environment or VM image.
+   */
+  readonly value: string;
+}
+interface ManagedVmRequestMediation {
+  readonly onRequest?: (request: Request) => Promise<Request | Response | void>;
+  readonly onResponse?: (response: Response) => Promise<Response | void>;
+}
+interface ManagedVmTcpHostMapping {
+  readonly guestHost: string;
+  readonly target: string;
+}
+interface ManagedVmGitReadOnlySshEgress {
+  readonly allowedHosts: readonly string[];
+  readonly allowedRepositories?: readonly string[];
+  readonly agentSocket?: string;
+  readonly kind: 'git-read-only';
+  readonly knownHostsFile?: string;
+}
+interface ManagedVmCreateRequest {
+  readonly allowedHosts: readonly string[];
+  readonly environment: Readonly<Record<string, string>>;
+  readonly imageReference: string;
+  readonly mediatedSecrets: readonly ManagedVmMediatedSecretDescriptor[];
+  readonly mediation?: ManagedVmRequestMediation;
+  readonly mounts: Readonly<Record<string, ManagedVmMount>>;
+  readonly resources: ManagedVmResources;
+  readonly rootfsMode: ManagedVmRootfsMode;
+  readonly runtimeRootfsSize?: string;
+  readonly sessionLabel: string;
+  readonly sshEgress?: ManagedVmGitReadOnlySshEgress;
+  readonly tcpHosts: readonly ManagedVmTcpHostMapping[];
+}
+interface ManagedVm {
+  close(): Promise<void>;
+  configureIngressRoutes(routes: readonly ManagedVmIngressRoute[]): void;
+  enableIngress(options?: ManagedVmIngressOptions): Promise<ManagedVmAccessHandle>;
+  enableSsh(options?: ManagedVmEnableSshOptions): Promise<ManagedVmSshAccess>;
+  exec(command: ManagedVmExecCommand, options?: ManagedVmExecOptions): ManagedVmExecProcess;
+  /** Null before start succeeds or after the owned host process exits. */
+  getHostProcessId(): number | null;
+  readonly id: string;
+  start(): Promise<void>;
+}
+/** Durable controller identity captured before authority admission. */
+interface ManagedVmHostProcessIdentity {
+  readonly command: string;
+  readonly hostProcessId: number;
+  readonly processStartIdentity: string;
+  readonly vmId: string;
+}
+interface ManagedVmExactProcessTerminationRequest {
+  readonly contextLabel: string;
+  readonly identity: ManagedVmHostProcessIdentity;
+}
+type ManagedVmExactProcessTerminationOutcome = {
+  readonly hostProcessId: number;
+  readonly kind: 'already-absent';
+} | {
+  readonly hostProcessId: number;
+  readonly kind: 'terminated';
+};
+interface ManagedVmExactProcessTerminationCapability {
+  terminateRecordedHostProcess(request: ManagedVmExactProcessTerminationRequest): Promise<ManagedVmExactProcessTerminationOutcome>;
+}
+interface ManagedVmFactory {
+  createManagedVm(request: ManagedVmCreateRequest): Promise<ManagedVm>;
+}
+interface ManagedVmImageBuildRequest {
+  readonly cacheDirectory: string;
+  readonly forceRebuild?: boolean;
+  readonly recipePath: string;
+}
+interface ManagedVmImageBuildResult {
+  readonly built: boolean;
+  readonly fingerprint: string;
+  readonly imageReference: string;
+}
+interface ManagedVmImageCapability {
+  prepareImage(request: ManagedVmImageBuildRequest): Promise<ManagedVmImageBuildResult>;
+}
+interface ManagedVmCompatibilityDiagnostic {
+  readonly code: string;
+  readonly message: string;
+  readonly severity: 'error' | 'warning';
+}
+interface ManagedVmDiagnosticsCapability {
+  checkCompatibility(): Promise<readonly ManagedVmCompatibilityDiagnostic[]>;
+}
+interface ManagedVmOwnedDirectoryCapability {
+  openHostDirectory(hostPath: string): OwnedHostDirectory;
+}
+/** Aggregate available only at application composition boundaries. */
+interface ManagedVmProvider {
+  readonly diagnostics: ManagedVmDiagnosticsCapability;
+  readonly exactProcessTermination: ManagedVmExactProcessTerminationCapability;
+  readonly factory: ManagedVmFactory;
+  readonly images: ManagedVmImageCapability;
+  readonly ownedDirectories: ManagedVmOwnedDirectoryCapability;
+}
+//#endregion
+//#region src/filtered-workspace-policy.d.ts
+/**
+ * Validates the complete policy before VM construction reaches a native provider.
+ * Paths are rejected rather than silently normalized so one spelling has one meaning.
+ */
+declare function validateManagedVmFilteredWorkspacePolicy(policy: ManagedVmFilteredWorkspacePolicy): ManagedVmFilteredWorkspacePolicy;
+//#endregion
+//#region src/owned-host-directory.d.ts
+interface OwnedHostDirectoryControllerOptions {
+  readonly identity: ManagedVmCanonicalDirectoryIdentity;
+  readonly onClose: () => void;
+  readonly onConsume?: () => void;
+}
+/**
+ * Creates the backend-neutral half of an owned-directory capability. Native
+ * resources remain captured by provider callbacks and never enter this object.
+ */
+declare function createOwnedHostDirectoryController(options: OwnedHostDirectoryControllerOptions): OwnedHostDirectory;
+declare function assertPositiveHostProcessId(hostProcessId: number | null): number;
+//#endregion
+export { ManagedVm, ManagedVmAccessHandle, ManagedVmCanonicalDirectoryIdentity, ManagedVmCompatibilityDiagnostic, ManagedVmCreateRequest, ManagedVmDiagnosticsCapability, ManagedVmEnableSshOptions, ManagedVmExactProcessTerminationCapability, ManagedVmExactProcessTerminationOutcome, ManagedVmExactProcessTerminationRequest, ManagedVmExecCommand, ManagedVmExecOptions, ManagedVmExecOutputChunk, ManagedVmExecProcess, ManagedVmExecResult, ManagedVmExecStreamMode, ManagedVmExecStreamingOptions, ManagedVmFactory, ManagedVmFilteredWorkspacePolicy, ManagedVmFilteredWorkspaceReadonlyInput, ManagedVmFilteredWorkspaceVisibility, ManagedVmGitReadOnlySshEgress, ManagedVmHostProcessIdentity, ManagedVmImageBuildRequest, ManagedVmImageBuildResult, ManagedVmImageCapability, ManagedVmIngressOptions, ManagedVmIngressRoute, ManagedVmMediatedSecretDescriptor, ManagedVmMount, ManagedVmOwnedDirectoryCapability, ManagedVmProvider, ManagedVmRequestMediation, ManagedVmResources, ManagedVmRootfsMode, ManagedVmSshAccess, ManagedVmSshServerHostKey, ManagedVmTcpHostMapping, OwnedHostDirectory, OwnedHostDirectoryControllerOptions, OwnedHostDirectoryState, OwnedHostDirectoryTransfer, assertPositiveHostProcessId, createOwnedHostDirectoryController, validateManagedVmFilteredWorkspacePolicy };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/managed-vm-contracts.ts","../src/filtered-workspace-policy.ts","../src/owned-host-directory.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,162 @@
+import path from "node:path";
+//#region src/filtered-workspace-policy.ts
+function assertNormalizedRelativePath(relativePath, fieldName) {
+	if (relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || relativePath.endsWith("/") || path.posix.isAbsolute(relativePath) || path.posix.normalize(relativePath) !== relativePath || relativePath.split("/").some((segment) => segment === "." || segment === "..")) throw new Error(`${fieldName} must be a normalized workspace-relative path: ${relativePath}`);
+}
+function isEqualOrDescendant(candidatePath, ancestorPath) {
+	return candidatePath === ancestorPath || candidatePath.startsWith(`${ancestorPath}/`);
+}
+function pathsOverlap(firstPath, secondPath) {
+	return isEqualOrDescendant(firstPath, secondPath) || isEqualOrDescendant(secondPath, firstPath);
+}
+function validatePathSet(paths, label) {
+	for (const relativePath of paths) assertNormalizedRelativePath(relativePath, label);
+	const seenPaths = /* @__PURE__ */ new Set();
+	for (const relativePath of paths) {
+		if (seenPaths.has(relativePath)) throw new Error(`Managed filtered workspace policy has a duplicate ${label}: ${relativePath}`);
+		seenPaths.add(relativePath);
+	}
+	for (let pathIndex = 0; pathIndex < paths.length; pathIndex += 1) {
+		const firstPath = paths[pathIndex];
+		if (!firstPath) continue;
+		for (let comparedIndex = pathIndex + 1; comparedIndex < paths.length; comparedIndex += 1) {
+			const secondPath = paths[comparedIndex];
+			if (secondPath && pathsOverlap(firstPath, secondPath)) throw new Error(`Managed filtered workspace policy has overlapping ${label}s: ${firstPath} and ${secondPath}`);
+		}
+	}
+}
+function validateReadonlyInputs(readonlyInputs) {
+	for (const readonlyInput of readonlyInputs) {
+		assertNormalizedRelativePath(readonlyInput.sourceRelativePath, "Read-only input source path");
+		assertNormalizedRelativePath(readonlyInput.destinationRelativePath, "Read-only input destination path");
+	}
+	const destinationPaths = readonlyInputs.map((readonlyInput) => readonlyInput.destinationRelativePath);
+	const seenDestinations = /* @__PURE__ */ new Set();
+	for (const destinationPath of destinationPaths) {
+		if (seenDestinations.has(destinationPath)) throw new Error(`Managed filtered workspace policy has a duplicate read-only destination: ${destinationPath}`);
+		seenDestinations.add(destinationPath);
+	}
+	for (let inputIndex = 0; inputIndex < destinationPaths.length; inputIndex += 1) {
+		const firstDestination = destinationPaths[inputIndex];
+		if (!firstDestination) continue;
+		for (let comparedIndex = inputIndex + 1; comparedIndex < destinationPaths.length; comparedIndex += 1) {
+			const secondDestination = destinationPaths[comparedIndex];
+			if (secondDestination && pathsOverlap(firstDestination, secondDestination)) throw new Error(`Managed filtered workspace policy has overlapping read-only destinations: ${firstDestination} and ${secondDestination}`);
+		}
+	}
+}
+function assertWithinPositiveVisibility(relativePath, visiblePaths, fieldName) {
+	if (!visiblePaths.some((visiblePath) => isEqualOrDescendant(relativePath, visiblePath))) throw new Error(`${fieldName} '${relativePath}' is outside the positive visibility allowlist.`);
+}
+function readonlyInputSourceIsWritable(readonlyInput, policy) {
+	const sourcePath = readonlyInput.sourceRelativePath;
+	if (policy.hiddenPaths.some((hiddenPath) => isEqualOrDescendant(sourcePath, hiddenPath)) || policy.temporaryPaths.some((temporaryPath) => isEqualOrDescendant(sourcePath, temporaryPath)) || policy.readonlyInputs.some((candidateInput) => isEqualOrDescendant(sourcePath, candidateInput.destinationRelativePath))) return false;
+	if (policy.visibility.kind === "whole-root-writable") return true;
+	return policy.visibility.writablePaths.some((writablePath) => isEqualOrDescendant(sourcePath, writablePath));
+}
+/**
+* Validates the complete policy before VM construction reaches a native provider.
+* Paths are rejected rather than silently normalized so one spelling has one meaning.
+*/
+function validateManagedVmFilteredWorkspacePolicy(policy) {
+	validatePathSet(policy.hiddenPaths, "hidden path");
+	validatePathSet(policy.temporaryPaths, "temporary path");
+	validateReadonlyInputs(policy.readonlyInputs);
+	if (policy.visibility.kind === "positive-paths") {
+		validatePathSet(policy.visibility.visiblePaths, "visible path");
+		validatePathSet(policy.visibility.writablePaths, "writable path");
+		if (policy.visibility.visiblePaths.length === 0) throw new Error("A positive filtered workspace policy must admit at least one visible path.");
+		for (const writablePath of policy.visibility.writablePaths) assertWithinPositiveVisibility(writablePath, policy.visibility.visiblePaths, "Writable path");
+		for (const temporaryPath of policy.temporaryPaths) assertWithinPositiveVisibility(temporaryPath, policy.visibility.visiblePaths, "Temporary path");
+		for (const readonlyInput of policy.readonlyInputs) assertWithinPositiveVisibility(readonlyInput.destinationRelativePath, policy.visibility.visiblePaths, "Read-only destination");
+		for (const hiddenPath of policy.hiddenPaths) if (!policy.visibility.visiblePaths.some((visiblePath) => pathsOverlap(hiddenPath, visiblePath))) throw new Error(`Hidden path '${hiddenPath}' is outside the positive visibility allowlist.`);
+	}
+	for (const readonlyInput of policy.readonlyInputs) {
+		if (readonlyInputSourceIsWritable(readonlyInput, policy)) throw new Error(`Read-only input source '${readonlyInput.sourceRelativePath}' remains writable at its original workspace path.`);
+		for (const writablePath of policy.visibility.kind === "positive-paths" ? policy.visibility.writablePaths : []) if (writablePath !== readonlyInput.destinationRelativePath && isEqualOrDescendant(writablePath, readonlyInput.destinationRelativePath)) throw new Error(`writable path '${writablePath}' has read-only ancestor '${readonlyInput.destinationRelativePath}'.`);
+	}
+	return {
+		hiddenPaths: [...policy.hiddenPaths],
+		readonlyInputs: policy.readonlyInputs.map((readonlyInput) => ({ ...readonlyInput })),
+		temporaryPaths: [...policy.temporaryPaths],
+		visibility: policy.visibility.kind === "whole-root-writable" ? { kind: "whole-root-writable" } : {
+			kind: "positive-paths",
+			visiblePaths: [...policy.visibility.visiblePaths],
+			writablePaths: [...policy.visibility.writablePaths]
+		}
+	};
+}
+//#endregion
+//#region src/owned-host-directory.ts
+/**
+* Creates the backend-neutral half of an owned-directory capability. Native
+* resources remain captured by provider callbacks and never enter this object.
+*/
+function createOwnedHostDirectoryController(options) {
+	let currentState = "acquired";
+	let resourceClosed = false;
+	let resourceClosing = false;
+	const getInternalState = () => currentState;
+	const closeResource = () => {
+		if (resourceClosed) return true;
+		if (resourceClosing) return false;
+		resourceClosing = true;
+		try {
+			options.onClose();
+			resourceClosed = true;
+			return true;
+		} finally {
+			resourceClosing = false;
+		}
+	};
+	const transfer = {
+		close() {
+			if (currentState !== "adapter-owned") return;
+			if (closeResource()) currentState = "closed";
+		},
+		get identity() {
+			return options.identity;
+		},
+		get state() {
+			return currentState === "adapter-owned" ? "adapter-owned" : "closed";
+		}
+	};
+	return {
+		close() {
+			if (currentState === "adapter-owned") throw new Error("Owned host directory cannot be closed by its former owner after transfer.");
+			if (getInternalState() === "closed") return;
+			if (closeResource()) currentState = "closed";
+		},
+		consume() {
+			if (currentState !== "acquired") throw new Error(`Owned host directory cannot be consumed while ${currentState}.`);
+			currentState = "transferring";
+			try {
+				options.onConsume?.();
+			} catch (consumeError) {
+				try {
+					if (closeResource()) currentState = "closed";
+				} catch (closeError) {
+					throw new AggregateError([consumeError, closeError], "Owned host directory transfer and cleanup both failed.", { cause: consumeError });
+				}
+				throw consumeError;
+			}
+			if (getInternalState() === "closed") throw new Error("Owned host directory closed during ownership transfer.");
+			currentState = "adapter-owned";
+			return transfer;
+		},
+		get identity() {
+			return options.identity;
+		},
+		get state() {
+			return currentState === "transferring" ? "acquired" : currentState;
+		}
+	};
+}
+function assertPositiveHostProcessId(hostProcessId) {
+	if (!Number.isSafeInteger(hostProcessId) || hostProcessId === null || hostProcessId <= 0) throw new Error("A started managed VM must expose a positive stable host process ID.");
+	return hostProcessId;
+}
+//#endregion
+export { assertPositiveHostProcessId, createOwnedHostDirectoryController, validateManagedVmFilteredWorkspacePolicy };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/filtered-workspace-policy.ts","../src/owned-host-directory.ts"],"sourcesContent":["import path from 'node:path';\n\nimport type {\n\tManagedVmFilteredWorkspacePolicy,\n\tManagedVmFilteredWorkspaceReadonlyInput,\n} from './managed-vm-contracts.js';\n\nfunction assertNormalizedRelativePath(relativePath: string, fieldName: string): void {\n\tif (\n\t\trelativePath.length === 0 ||\n\t\trelativePath.includes('\\0') ||\n\t\trelativePath.includes('\\\\') ||\n\t\trelativePath.endsWith('/') ||\n\t\tpath.posix.isAbsolute(relativePath) ||\n\t\tpath.posix.normalize(relativePath) !== relativePath ||\n\t\trelativePath.split('/').some((segment) => segment === '.' || segment === '..')\n\t) {\n\t\tthrow new Error(`${fieldName} must be a normalized workspace-relative path: ${relativePath}`);\n\t}\n}\n\nfunction isEqualOrDescendant(candidatePath: string, ancestorPath: string): boolean {\n\treturn candidatePath === ancestorPath || candidatePath.startsWith(`${ancestorPath}/`);\n}\n\nfunction pathsOverlap(firstPath: string, secondPath: string): boolean {\n\treturn isEqualOrDescendant(firstPath, secondPath) || isEqualOrDescendant(secondPath, firstPath);\n}\n\nfunction validatePathSet(paths: readonly string[], label: string): void {\n\tfor (const relativePath of paths) {\n\t\tassertNormalizedRelativePath(relativePath, label);\n\t}\n\tconst seenPaths = new Set<string>();\n\tfor (const relativePath of paths) {\n\t\tif (seenPaths.has(relativePath)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Managed filtered workspace policy has a duplicate ${label}: ${relativePath}`,\n\t\t\t);\n\t\t}\n\t\tseenPaths.add(relativePath);\n\t}\n\tfor (let pathIndex = 0; pathIndex < paths.length; pathIndex += 1) {\n\t\tconst firstPath = paths[pathIndex];\n\t\tif (!firstPath) {\n\t\t\tcontinue;\n\t\t}\n\t\tfor (let comparedIndex = pathIndex + 1; comparedIndex < paths.length; comparedIndex += 1) {\n\t\t\tconst secondPath = paths[comparedIndex];\n\t\t\tif (secondPath && pathsOverlap(firstPath, secondPath)) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Managed filtered workspace policy has overlapping ${label}s: ${firstPath} and ${secondPath}`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction validateReadonlyInputs(\n\treadonlyInputs: readonly ManagedVmFilteredWorkspaceReadonlyInput[],\n): void {\n\tfor (const readonlyInput of readonlyInputs) {\n\t\tassertNormalizedRelativePath(readonlyInput.sourceRelativePath, 'Read-only input source path');\n\t\tassertNormalizedRelativePath(\n\t\t\treadonlyInput.destinationRelativePath,\n\t\t\t'Read-only input destination path',\n\t\t);\n\t}\n\tconst destinationPaths = readonlyInputs.map(\n\t\t(readonlyInput) => readonlyInput.destinationRelativePath,\n\t);\n\tconst seenDestinations = new Set<string>();\n\tfor (const destinationPath of destinationPaths) {\n\t\tif (seenDestinations.has(destinationPath)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Managed filtered workspace policy has a duplicate read-only destination: ${destinationPath}`,\n\t\t\t);\n\t\t}\n\t\tseenDestinations.add(destinationPath);\n\t}\n\tfor (let inputIndex = 0; inputIndex < destinationPaths.length; inputIndex += 1) {\n\t\tconst firstDestination = destinationPaths[inputIndex];\n\t\tif (!firstDestination) {\n\t\t\tcontinue;\n\t\t}\n\t\tfor (\n\t\t\tlet comparedIndex = inputIndex + 1;\n\t\t\tcomparedIndex < destinationPaths.length;\n\t\t\tcomparedIndex += 1\n\t\t) {\n\t\t\tconst secondDestination = destinationPaths[comparedIndex];\n\t\t\tif (secondDestination && pathsOverlap(firstDestination, secondDestination)) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Managed filtered workspace policy has overlapping read-only destinations: ${firstDestination} and ${secondDestination}`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction assertWithinPositiveVisibility(\n\trelativePath: string,\n\tvisiblePaths: readonly string[],\n\tfieldName: string,\n): void {\n\tif (!visiblePaths.some((visiblePath) => isEqualOrDescendant(relativePath, visiblePath))) {\n\t\tthrow new Error(`${fieldName} '${relativePath}' is outside the positive visibility allowlist.`);\n\t}\n}\n\nfunction readonlyInputSourceIsWritable(\n\treadonlyInput: ManagedVmFilteredWorkspaceReadonlyInput,\n\tpolicy: ManagedVmFilteredWorkspacePolicy,\n): boolean {\n\tconst sourcePath = readonlyInput.sourceRelativePath;\n\tif (\n\t\tpolicy.hiddenPaths.some((hiddenPath) => isEqualOrDescendant(sourcePath, hiddenPath)) ||\n\t\tpolicy.temporaryPaths.some((temporaryPath) => isEqualOrDescendant(sourcePath, temporaryPath)) ||\n\t\tpolicy.readonlyInputs.some((candidateInput) =>\n\t\t\tisEqualOrDescendant(sourcePath, candidateInput.destinationRelativePath),\n\t\t)\n\t) {\n\t\treturn false;\n\t}\n\tif (policy.visibility.kind === 'whole-root-writable') {\n\t\treturn true;\n\t}\n\treturn policy.visibility.writablePaths.some((writablePath) =>\n\t\tisEqualOrDescendant(sourcePath, writablePath),\n\t);\n}\n\n/**\n * Validates the complete policy before VM construction reaches a native provider.\n * Paths are rejected rather than silently normalized so one spelling has one meaning.\n */\nexport function validateManagedVmFilteredWorkspacePolicy(\n\tpolicy: ManagedVmFilteredWorkspacePolicy,\n): ManagedVmFilteredWorkspacePolicy {\n\tvalidatePathSet(policy.hiddenPaths, 'hidden path');\n\tvalidatePathSet(policy.temporaryPaths, 'temporary path');\n\tvalidateReadonlyInputs(policy.readonlyInputs);\n\n\tif (policy.visibility.kind === 'positive-paths') {\n\t\tvalidatePathSet(policy.visibility.visiblePaths, 'visible path');\n\t\tvalidatePathSet(policy.visibility.writablePaths, 'writable path');\n\t\tif (policy.visibility.visiblePaths.length === 0) {\n\t\t\tthrow new Error('A positive filtered workspace policy must admit at least one visible path.');\n\t\t}\n\t\tfor (const writablePath of policy.visibility.writablePaths) {\n\t\t\tassertWithinPositiveVisibility(writablePath, policy.visibility.visiblePaths, 'Writable path');\n\t\t}\n\t\tfor (const temporaryPath of policy.temporaryPaths) {\n\t\t\tassertWithinPositiveVisibility(\n\t\t\t\ttemporaryPath,\n\t\t\t\tpolicy.visibility.visiblePaths,\n\t\t\t\t'Temporary path',\n\t\t\t);\n\t\t}\n\t\tfor (const readonlyInput of policy.readonlyInputs) {\n\t\t\tassertWithinPositiveVisibility(\n\t\t\t\treadonlyInput.destinationRelativePath,\n\t\t\t\tpolicy.visibility.visiblePaths,\n\t\t\t\t'Read-only destination',\n\t\t\t);\n\t\t}\n\t\tfor (const hiddenPath of policy.hiddenPaths) {\n\t\t\tif (\n\t\t\t\t!policy.visibility.visiblePaths.some((visiblePath) => pathsOverlap(hiddenPath, visiblePath))\n\t\t\t) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Hidden path '${hiddenPath}' is outside the positive visibility allowlist.`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tfor (const readonlyInput of policy.readonlyInputs) {\n\t\tif (readonlyInputSourceIsWritable(readonlyInput, policy)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Read-only input source '${readonlyInput.sourceRelativePath}' remains writable at its original workspace path.`,\n\t\t\t);\n\t\t}\n\t\tfor (const writablePath of policy.visibility.kind === 'positive-paths'\n\t\t\t? policy.visibility.writablePaths\n\t\t\t: []) {\n\t\t\tif (\n\t\t\t\twritablePath !== readonlyInput.destinationRelativePath &&\n\t\t\t\tisEqualOrDescendant(writablePath, readonlyInput.destinationRelativePath)\n\t\t\t) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`writable path '${writablePath}' has read-only ancestor '${readonlyInput.destinationRelativePath}'.`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn {\n\t\thiddenPaths: [...policy.hiddenPaths],\n\t\treadonlyInputs: policy.readonlyInputs.map((readonlyInput) => ({ ...readonlyInput })),\n\t\ttemporaryPaths: [...policy.temporaryPaths],\n\t\tvisibility:\n\t\t\tpolicy.visibility.kind === 'whole-root-writable'\n\t\t\t\t? { kind: 'whole-root-writable' }\n\t\t\t\t: {\n\t\t\t\t\t\tkind: 'positive-paths',\n\t\t\t\t\t\tvisiblePaths: [...policy.visibility.visiblePaths],\n\t\t\t\t\t\twritablePaths: [...policy.visibility.writablePaths],\n\t\t\t\t\t},\n\t};\n}\n","import type {\n\tManagedVmCanonicalDirectoryIdentity,\n\tOwnedHostDirectory,\n\tOwnedHostDirectoryState,\n\tOwnedHostDirectoryTransfer,\n} from './managed-vm-contracts.js';\n\nexport interface OwnedHostDirectoryControllerOptions {\n\treadonly identity: ManagedVmCanonicalDirectoryIdentity;\n\treadonly onClose: () => void;\n\treadonly onConsume?: () => void;\n}\n\n/**\n * Creates the backend-neutral half of an owned-directory capability. Native\n * resources remain captured by provider callbacks and never enter this object.\n */\nexport function createOwnedHostDirectoryController(\n\toptions: OwnedHostDirectoryControllerOptions,\n): OwnedHostDirectory {\n\ttype InternalOwnedHostDirectoryState = OwnedHostDirectoryState | 'transferring';\n\tlet currentState: InternalOwnedHostDirectoryState = 'acquired';\n\tlet resourceClosed = false;\n\tlet resourceClosing = false;\n\tconst getInternalState = (): InternalOwnedHostDirectoryState => currentState;\n\n\tconst closeResource = (): boolean => {\n\t\tif (resourceClosed) {\n\t\t\treturn true;\n\t\t}\n\t\tif (resourceClosing) {\n\t\t\treturn false;\n\t\t}\n\t\tresourceClosing = true;\n\t\ttry {\n\t\t\toptions.onClose();\n\t\t\tresourceClosed = true;\n\t\t\treturn true;\n\t\t} finally {\n\t\t\tresourceClosing = false;\n\t\t}\n\t};\n\n\tconst transfer: OwnedHostDirectoryTransfer = {\n\t\tclose(): void {\n\t\t\tif (currentState !== 'adapter-owned') {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (closeResource()) {\n\t\t\t\tcurrentState = 'closed';\n\t\t\t}\n\t\t},\n\t\tget identity(): ManagedVmCanonicalDirectoryIdentity {\n\t\t\treturn options.identity;\n\t\t},\n\t\tget state(): 'adapter-owned' | 'closed' {\n\t\t\treturn currentState === 'adapter-owned' ? 'adapter-owned' : 'closed';\n\t\t},\n\t};\n\n\treturn {\n\t\tclose(): void {\n\t\t\tif (currentState === 'adapter-owned') {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t'Owned host directory cannot be closed by its former owner after transfer.',\n\t\t\t\t);\n\t\t\t}\n\t\t\tif (getInternalState() === 'closed') {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (closeResource()) {\n\t\t\t\tcurrentState = 'closed';\n\t\t\t}\n\t\t},\n\t\tconsume(): OwnedHostDirectoryTransfer {\n\t\t\tif (currentState !== 'acquired') {\n\t\t\t\tthrow new Error(`Owned host directory cannot be consumed while ${currentState}.`);\n\t\t\t}\n\t\t\tcurrentState = 'transferring';\n\t\t\ttry {\n\t\t\t\toptions.onConsume?.();\n\t\t\t} catch (consumeError) {\n\t\t\t\ttry {\n\t\t\t\t\tif (closeResource()) {\n\t\t\t\t\t\tcurrentState = 'closed';\n\t\t\t\t\t}\n\t\t\t\t} catch (closeError) {\n\t\t\t\t\t// oxlint-disable-next-line preserve-caught-error -- AggregateError.errors retains cleanup failure while cause retains the transfer failure.\n\t\t\t\t\tthrow new AggregateError(\n\t\t\t\t\t\t[consumeError, closeError],\n\t\t\t\t\t\t'Owned host directory transfer and cleanup both failed.',\n\t\t\t\t\t\t{ cause: consumeError },\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tthrow consumeError;\n\t\t\t}\n\t\t\tif (getInternalState() === 'closed') {\n\t\t\t\tthrow new Error('Owned host directory closed during ownership transfer.');\n\t\t\t}\n\t\t\tcurrentState = 'adapter-owned';\n\t\t\treturn transfer;\n\t\t},\n\t\tget identity(): ManagedVmCanonicalDirectoryIdentity {\n\t\t\treturn options.identity;\n\t\t},\n\t\tget state(): OwnedHostDirectoryState {\n\t\t\treturn currentState === 'transferring' ? 'acquired' : currentState;\n\t\t},\n\t};\n}\n\nexport function assertPositiveHostProcessId(hostProcessId: number | null): number {\n\tif (!Number.isSafeInteger(hostProcessId) || hostProcessId === null || hostProcessId <= 0) {\n\t\tthrow new Error('A started managed VM must expose a positive stable host process ID.');\n\t}\n\treturn hostProcessId;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@agent-vm/managed-vm",
+  "version": "0.0.115",
+  "description": "Backend-neutral managed VM contracts and ownership semantics for agent-vm.",
+  "homepage": "https://github.com/ShravanSunder/agent-vm#readme",
+  "bugs": {
+    "url": "https://github.com/ShravanSunder/agent-vm/issues"
+  },
+  "license": "MIT",
+  "author": "Shravan Sunder <ShravanSunder@users.noreply.github.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShravanSunder/agent-vm.git",
+    "directory": "packages/managed-vm"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "pnpm test:unit",
+    "test:unit": "vitest run --root ../../ --config vitest.config.ts --project unit packages/managed-vm/src"
+  }
+}