@vibesdotdev/platform 0.0.0-stage → 1.0.0-rc.1

package/dist/fleets/daemon/execution-listen-policy.d.ts

@@ -0,0 +1,497 @@
+/**
+ * The execution listen policy — how the fleet daemon exposes a `runtime/execution`
+ * impl over the `runtime/rpc` wire (fleet.md §4.2, §4.3; L6d phase 4).
+ *
+ * The L4b transport (`runtime-rpc-http`) is kind-agnostic: it never names a kind,
+ * a method, or a channel. So the daemon must supply the *listen policy* that tells
+ * the protocol which owner return values become refs (a `session`/`handle` is a
+ * ref; a plain result is inline JSON) and how the opaque `'pty'` channel maps onto
+ * a session's `onOutput`/`write`/`kill`. This is the canonical version of the
+ * policy each transport test reproduces inline — the daemon ships it once.
+ *
+ * This module carries NO authz/friction logic and NO transport plumbing. The gates
+ * are L5's (run inside the L1 invoke pipeline the daemon mounts, §4.5); the
+ * transport is L4b's. This is purely the kind↔wire shape for `runtime/execution`.
+ */
+import { type ReferenceOwnership, type ChildEnvRuntime } from '@vibesdotdev/kernel';
+import { type ExecuteResult, type ExecutionSession, type ProcessHandle, type RuntimeExecution } from '@vibesdotdev/kernel/execution';
+import type { FileSystemAdapterInterface } from '@vibesdotdev/filesystem';
+import { type FileContentWire } from '@vibesdotdev/filesystem/wire';
+import type { WireClassifier, ChannelBinder, StreamBinding, RpcSource } from '@vibesdotdev/kernel-rpc';
+import { type WorkspaceCustody } from '@vibesdotdev/workspace-schemas/custody';
+/** The kind id the daemon exposes execution under (gate context + diagnostics). */
+export declare const EXECUTION_KIND_ID = "runtime/execution";
+/** The opaque stream channel name the PTY session's byte stream rides. */
+export declare const PTY_CHANNEL = "pty";
+/** The spawned-process stream channel names (`spawn()` mode over the wire). */
+export declare const STDOUT_CHANNEL = "stdout";
+export declare const STDERR_CHANNEL = "stderr";
+export declare const STDIN_CHANNEL = "stdin";
+/**
+ * The opaque stream channel a proxied `filesystem/adapter` watch's change events
+ * ride (UNIT-A8, the B3 residual). A live change CALLBACK has no inline wire
+ * representation, exactly as a PTY session's `onOutput` has none — so it rides the
+ * `stream` verb, the SAME wire representation the PTY byte channel uses. The
+ * consumer side (`agent-code-session/src/remote-workspace-fs.ts`) opens this same
+ * channel name by convention (the two packages are wire-independent, like
+ * `REMOTE_FILESYSTEM_WIRE_METHODS`).
+ */
+export declare const WATCH_CHANNEL = "fs-watch";
+/**
+ * The async I/O method names a proxied `filesystem/adapter` exposes over the wire
+ * (path utilities are pure and run consumer-side, so they are NOT proxied). The
+ * daemon-side counterpart of the consumer's `REMOTE_FILESYSTEM_WIRE_METHODS` — the
+ * two agree by convention (wire-independent packages). `watch` is proxied
+ * separately (it returns a {@link WireFilesystemWatch} ref, not an inline result).
+ */
+export declare const FILESYSTEM_IO_WIRE_METHODS: readonly ["exists", "stat", "readFile", "writeFile", "list", "mkdir", "remove", "rename", "copy", "glob"];
+/** A single filesystem change event as it crosses the {@link WATCH_CHANNEL} stream. */
+export interface FileWatchEvent {
+    readonly eventType: string;
+    readonly filename: string;
+}
+/**
+ * The WIRE shape of a `filesystem/adapter` watch (mirrors {@link WireProcessHandle}).
+ * A proxied adapter's `watch(path)` returns this: its change events ride the
+ * {@link WATCH_CHANNEL} stream ({@link bindExecutionChannel}), and `close()` releases
+ * the host watch. The change callback the local `watch(path, callback)` takes has no
+ * inline wire representation — the `stream` verb IS its representation.
+ */
+export interface WireFilesystemWatch {
+    /** Brand so the classifier + channel binder recognise a watch handle. */
+    readonly __fleetFsWatch: true;
+    /**
+     * Subscribe to change events. Each event is delivered to `onEvent` until the
+     * returned unsubscribe runs or the watch is {@link WireFilesystemWatch.close}d.
+     * Events observed before the FIRST subscriber attaches are buffered and flushed
+     * in order (the host watch starts eagerly so a bad path rejects the `watch`
+     * invoke, never a silently-dead stream).
+     */
+    subscribe(onEvent: (event: FileWatchEvent) => void): () => void;
+    /** Release the host watch entirely (the consumer closed the stream / released). */
+    close(): void;
+}
+/**
+ * The host-side async surface a {@link wrapFilesystemAdapterForWire} needs: the ten
+ * proxied I/O methods plus the live `watch(path, callback)`. Structurally a
+ * `FileSystemAdapterInterface` (fleet-daemon stays free of a `@vibesdotdev/filesystem`
+ * dependency — it only needs this shape).
+ */
+export type WatchableFilesystemAdapter = Pick<FileSystemAdapterInterface, (typeof FILESYSTEM_IO_WIRE_METHODS)[number] | 'watch' | 'observeFile' | 'readFileObserved' | 'readFileVersioned' | 'writeFileConditional'> & Partial<Pick<FileSystemAdapterInterface, 'descriptor'>>;
+/**
+ * The wire surface of `RuntimeExecution` — the methods a consumer invokes back
+ * across the boundary once it has resolved the host's execution impl as a ref.
+ */
+export declare const EXECUTION_REF_METHODS: readonly ["execute", "spawn", "session", "resolveCommand", "getCapabilities", "healthCheck"];
+/** Structural guard: is this owner value the host's {@link RuntimeExecution} impl? */
+export declare function isRuntimeExecution<Value>(value: Value): value is Value & RuntimeExecution;
+/**
+ * The wire surface of the read-only `autoloop/monitor` (fleet fan-out). A consumer
+ * invokes these back across the boundary once it has resolved the host's monitor
+ * as a ref via `query('autoloop/monitor')`.
+ */
+export declare const MONITOR_REF_METHODS: readonly ["listLoops", "getLoop", "listEvents"];
+/**
+ * Structural guard: is this owner value the read-only `autoloop/monitor` impl? It
+ * has exactly the three read methods and no execution methods (so it is never
+ * confused with a RuntimeExecution). Used to classify it as a wire ref.
+ */
+export declare function isLoopMonitor<Value>(value: Value): boolean;
+/** Structural guard: is this owner value an interactive PTY {@link ExecutionSession}? */
+export declare function isExecutionSession<Value>(value: Value): value is Value & ExecutionSession;
+/** Structural guard: is this owner value a non-PTY {@link ProcessHandle}? */
+export declare function isProcessHandle<Value>(value: Value): value is Value & ProcessHandle;
+/**
+ * The WIRE shape of a spawned process (fleet.md §4.2 — execution over RPC).
+ *
+ * `ProcessHandle.exited` is a Promise PROPERTY — not invocable, so a remote
+ * `handle.exited()` dispatched over `invoke` hits the protocol's
+ * `typeof method !== 'function' → NO_METHOD` guard. And its stdout/stderr/
+ * stdin `ReadableStream`/`WritableStream`s have no inline JSON encoding. This
+ * adapter is the owner-side bridge: `exited` becomes a method, and the std
+ * streams stay attached as properties for {@link bindExecutionChannel} to bind
+ * onto the `'stdout'`/`'stderr'`/`'stdin'` channels.
+ */
+export interface WireProcessHandle {
+    /** Local lifetime metadata; never advertised or encoded on the wire. */
+    readonly ownership?: ReferenceOwnership;
+    readonly pid: number;
+    readonly stdout: ReadableStream<Uint8Array> | null;
+    readonly stderr: ReadableStream<Uint8Array> | null;
+    readonly stdin: WritableStream<Uint8Array> | null;
+    /** The process identity as a method: an RPC proxy cannot read a raw property. */
+    info(): Promise<{
+        pid: number;
+    }>;
+    /** Method form of `ProcessHandle.exited` so a remote invoke resolves it. */
+    exited(): Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+    /**
+     * The handle's kill, forwarded: its acknowledgement (or rejection) returned
+     * unchanged. Outputs are left alone, so a later-opened output still reads
+     * whatever the process wrote, to its EOF.
+     */
+    kill(signal?: string): void | Promise<void>;
+    /**
+     * Abandon the process: kill it, and release every output no channel was
+     * opened for (a consumer that never received the port can never open or
+     * close them). Resolves only when the kill and every release succeeded;
+     * otherwise rejects typed (`execution-wire-cleanup-failed`) keeping each
+     * cause. Memoized: a repeat returns the same promise.
+     */
+    abandon(signal?: string): Promise<void>;
+    /** Write bytes to the process's stdin and resolve once they are written (an awaited RPC). */
+    writeStdin(data: number[]): Promise<void>;
+    /** Close the process's stdin (its EOF) and resolve once it is closed. */
+    closeStdin(): Promise<void>;
+    /**
+     * Owner-side only (never advertised): the stream binding of an output
+     * channel (`'stdout'`/`'stderr'`), or `null` when the process has none.
+     */
+    outputBinding(channel: string): StreamBinding | null;
+}
+/** The wire methods of a spawned process, as the consumer's `adaptWireProcessHandle` reaches them. */
+export declare const PROCESS_REF_METHODS: readonly ["info", "exited", "kill", "abandon", "writeStdin", "closeStdin"];
+/** Structural guard: a process handle whose `exited` is already invocable. */
+export declare function isWireProcessHandle<Value>(value: Value): value is Value & WireProcessHandle;
+/** Wrap an owner-side {@link ProcessHandle} into its wire shape. */
+export declare function toWireProcessHandle(handle: ProcessHandle, custody: 'caller' | 'handoff'): WireProcessHandle;
+/** Structural guard: is this owner value a {@link WireFilesystemWatch}? */
+export declare function isWireFilesystemWatch<Value>(value: Value): value is Value & WireFilesystemWatch;
+/**
+ * Build a host-side {@link WireFilesystemWatch} over a local adapter's async
+ * `watch(path, callback)`. The host watch starts EAGERLY (so a bad path rejects the
+ * `watch(path)` invoke — never a silently-dead stream); events observed before the
+ * FIRST subscriber attaches buffer in order and flush on attach (mirroring the
+ * http transport's pre-attach frame buffer). `close()` releases the host watch.
+ */
+export declare function createFilesystemWatchHandle(adapter: WatchableFilesystemAdapter, path: string): Promise<WireFilesystemWatch>;
+/**
+ * Wrap a host-side {@link WatchableFilesystemAdapter} as a {@link ProxiedKind} the
+ * daemon proxies under `filesystem/adapter` (D-DAEMON-CLIENT). The ten async I/O
+ * methods forward untouched; `watch(path)` returns a {@link WireFilesystemWatch}
+ * whose change events ride the {@link WATCH_CHANNEL} stream. Path utilities stay
+ * pure/consumer-side and are deliberately NOT proxied. Pass the result to
+ * `startFleetDaemon({ resolveKind })` (or a `KindResolver`).
+ */
+export declare function wrapFilesystemAdapterForWire(adapter: WatchableFilesystemAdapter): {
+    impl: {
+        describe: (() => Promise<{
+            id: string;
+            kind: "filesystem/adapter";
+            protocols: ("file" | "directory" | "symlink" | "special")[];
+            capabilities: ("link" | "read" | "write" | "stat" | "list" | "realpath" | "touch" | "watch" | "move" | "copy" | "trash" | "glob" | "glob-pruning" | "versioned-file" | "file-observation" | "exclusive-create" | "temporary-directory" | "owner-private" | "stream-write" | "chmod" | "append" | "append-stream" | "read-range" | "read-sync" | "mutation-sync" | "special-entry-type" | "recursive-watch" | "volume-capacity")[];
+            supportsRecursive: boolean;
+            supportsWatch: boolean;
+            supportsSymlinks: boolean;
+            supportsHardLinks: boolean;
+            supportsPermissions: boolean;
+            supportsOwnership: boolean;
+            supportsExtendedAttributes: boolean;
+            persistent: boolean;
+            supportsTransactions: boolean;
+            supportsAtomic: boolean;
+            cloudNative: boolean;
+            supportsVersioning: boolean;
+            supportsGit: boolean;
+            supportsEncryption: boolean;
+            supportsCompression: boolean;
+            supportsQuota: boolean;
+            supportsACL: boolean;
+            supportsSearch: boolean;
+            name?: string | undefined;
+            description?: string | undefined;
+            tags?: string[] | undefined;
+            hardware?: string[] | undefined;
+            enabled?: boolean | undefined;
+            priority?: number | undefined;
+            capabilityId?: string | undefined;
+            requiredContext?: string[] | undefined;
+            optionalContext?: string[] | undefined;
+            config?: unknown;
+            retention?: string | {
+                reason: string;
+                maxAgeDays?: number | undefined;
+                maxEntries?: number | undefined;
+                maxBytes?: number | undefined;
+                cascadeFrom?: string | undefined;
+                ageField?: string | undefined;
+                enforcedBy?: string | undefined;
+            } | undefined;
+            versionedFile?: {
+                revisionScheme: string;
+                revisionScope: "file-content";
+                conditionalWrite?: {
+                    consistency: "process-cooperative" | "cross-process-cooperative" | "backend-atomic";
+                    writerSet: "adapter-instance-versioned-api" | "process-versioned-api" | "backend-all-writers";
+                    externalWritersFenced: boolean;
+                } | undefined;
+            } | undefined;
+        } | undefined>) | undefined;
+        exists: (path: string) => Promise<boolean>;
+        stat: (path: string) => Promise<{
+            kind: "file" | "directory" | "symlink" | "special";
+            size: number;
+            readable: boolean;
+            writable: boolean;
+            isSymlink: boolean;
+            specialType?: "socket" | "fifo" | "character-device" | "block-device" | "other" | undefined;
+            mtime?: string | undefined;
+            atime?: string | undefined;
+            ctime?: string | undefined;
+            birthtime?: string | undefined;
+            executable?: boolean | undefined;
+            symlinkTarget?: string | undefined;
+        }>;
+        readFile: (path: string, encoding?: import("@vibesdotdev/filesystem").FileEncoding | undefined) => Promise<string | number[]>;
+        observeFile: ((path: string) => Promise<{
+            status: "not-found";
+            reason: string;
+        } | {
+            status: "ok";
+            revision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+            sizeBytes: number;
+            modifiedAt: string;
+        } | {
+            status: "unavailable";
+            reason: string;
+            cause?: {
+                name: string;
+                code?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }>) | undefined;
+        readFileObserved: ((path: string, options: {
+            maxBytes: number;
+            expectedRevision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+        }) => Promise<{
+            status: "too-large";
+            reason: string;
+            sizeBytes: number;
+            maxBytes: number;
+        } | {
+            status: "not-found";
+            reason: string;
+        } | {
+            status: "binary";
+            reason: string;
+        } | {
+            status: "unsupported-encoding";
+            reason: string;
+        } | {
+            status: "conflict";
+            currentRevision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+        } | {
+            status: "unavailable";
+            reason: string;
+            cause?: {
+                name: string;
+                code?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | {
+            status: "ok";
+            revision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+            bytes: number[];
+        }>) | undefined;
+        readFileVersioned: ((path: string, options: {
+            maxBytes: number;
+        }) => Promise<{
+            status: "too-large";
+            reason: string;
+            sizeBytes: number;
+            maxBytes: number;
+        } | {
+            status: "not-found";
+            reason: string;
+        } | {
+            status: "binary";
+            reason: string;
+        } | {
+            status: "unsupported-encoding";
+            reason: string;
+        } | {
+            status: "conflict";
+            currentRevision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+        } | {
+            status: "unavailable";
+            reason: string;
+            cause?: {
+                name: string;
+                code?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        } | {
+            status: "ok";
+            revision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+            bytes: number[];
+        }>) | undefined;
+        writeFileConditional: ((path: string, data: number[], options: Parameters<(path: string, data: Uint8Array, options: import("@vibesdotdev/filesystem").ConditionalWriteOptions) => Promise<import("@vibesdotdev/filesystem").ConditionalWriteResult>>[2]) => Promise<{
+            status: "too-large";
+            reason: string;
+            sizeBytes: number;
+            maxBytes: number;
+        } | {
+            status: "conflict";
+            currentRevision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+        } | {
+            status: "saved";
+            revision: Readonly<{
+                scheme: string;
+                value: string;
+            }>;
+        } | {
+            status: "unavailable";
+            reason: string;
+            cause?: {
+                name: string;
+                code?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }>) | undefined;
+        writeFile: (path: string, data: FileContentWire, options?: Parameters<WatchableFilesystemAdapter["writeFile"]>[2]) => Promise<void>;
+        list: (path: string) => Promise<{
+            id: string;
+            name: string;
+            path: string;
+            kind: "file" | "directory" | "symlink" | "special";
+            specialType?: "socket" | "fifo" | "character-device" | "block-device" | "other" | undefined;
+            sizeBytes?: number | undefined;
+            modifiedAt?: string | undefined;
+            createdAt?: string | undefined;
+            readable?: boolean | undefined;
+            writable?: boolean | undefined;
+            executable?: boolean | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+        }[]>;
+        mkdir: (path: string, options?: {
+            recursive?: boolean;
+            mode?: number;
+        } | undefined) => Promise<void>;
+        remove: (path: string, options?: {
+            recursive?: boolean;
+        } | undefined) => Promise<void>;
+        rename: (oldPath: string, newPath: string) => Promise<void>;
+        copy: (source: string, destination: string, options?: {
+            recursive?: boolean;
+        } | undefined) => Promise<void>;
+        glob: (pattern: string, options?: {
+            cwd?: string;
+            absolute?: boolean;
+            ignore?: string[];
+        } | undefined) => Promise<string[]>;
+        watch: (path: string) => Promise<WireFilesystemWatch>;
+    };
+    methods: string[];
+};
+/** The selected native owner's authority stays on its host; a peer cannot add another hop. */
+export declare function wrapWorkspaceCustodyForWire(custody: WorkspaceCustody): {
+    impl: {
+        resolve: (id: string) => Promise<{
+            workspaceId: string;
+            label: string;
+            root: string;
+            remoteHostId?: string | undefined;
+            projectId?: string | null | undefined;
+        } | null>;
+        enroll: ((input: unknown) => Promise<{
+            workspaceId: string;
+            label: string;
+            root: string;
+            remoteHostId?: string | undefined;
+            projectId?: string | null | undefined;
+        }>) | undefined;
+    };
+    methods: string[];
+};
+/**
+ * The receiving host a declared request runs on: its own runtime composes every
+ * child environment, and its own signal is the only cancellation.
+ */
+export interface DeclaredExecutionHost {
+    /** The receiving host's own runtime; `composeDeclaredExecution`/`composeDeclaredSpawn` compose against it. */
+    readonly runtime: ChildEnvRuntime;
+    /** The receiving host's own cancellation (the daemon's lifetime). A remote signal never arrives. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * The fleet receiving operation (rc02-rc03 C15, cross-host). `execute`, `spawn`
+ * and `session` accept a DECLARED request, `{ command, args?, cwd?, …,
+ * declaration: { env?, inheritEnv? } }`, passed to the kernel as `unknown`:
+ * admission happens inside `composeDeclaredExecution`/`composeDeclaredSpawn`/
+ * `composeDeclaredSession`, which refuse `env`,
+ * `envMode` and `unsetEnv` (`declared-execution-env-injection`) and any unknown
+ * field or remote signal (`declared-execution-invalid`), then compose the child
+ * environment on THIS host's runtime with `envMode: 'replace'`. The caller's
+ * PATH and HOME never travel, and only the execution result crosses back.
+ *
+ * Every `spawn()` result crosses the wire as a {@link WireProcessHandle}. The
+ * daemon root applies this once, so the classifier/binder below only ever see
+ * the wire shape for spawned processes.
+ */
+export declare function wrapExecutionForWire(execution: RuntimeExecution, host: DeclaredExecutionHost): {
+    id: string;
+    descriptor: import("@vibesdotdev/kernel/execution").ExecutionDescriptor;
+    environmentId: string;
+    execute: (request: RpcSource) => Promise<ExecuteResult>;
+    spawn: (request: RpcSource) => Promise<WireProcessHandle>;
+    kill: (pid: number, signal?: string | undefined) => Promise<boolean>;
+    listSpawnedProcesses: () => Promise<import("@vibesdotdev/kernel/execution").SpawnedProcessInfo[]>;
+    session: (request: RpcSource) => Promise<ExecutionSession>;
+    resolveCommand: (command: string, options?: {
+        cwd?: string;
+        env?: Record<string, string | undefined>;
+    } | undefined) => Promise<string | null>;
+    getCapabilities: () => import("@vibesdotdev/kernel/execution").ExecutionCapabilities;
+    healthCheck: () => Promise<{
+        healthy: boolean;
+        latencyMs?: number;
+    }>;
+};
+/**
+ * Tag a host-side impl for the wire: returns a CLEAN forwarding object exposing
+ * exactly `methods` (each bound to `impl`) plus the {@link WIRE_REF_METHODS}
+ * marker. Forwarding (rather than mutating `impl`) keeps a shared impl — e.g. the
+ * host's single filesystem adapter — free of daemon-only markers, and guarantees
+ * only the declared async surface is reachable (a consumer proxy exposes only
+ * declared methods; undeclared props are `undefined`, matching local semantics).
+ */
+export declare function asWireRef<Implementation extends object>(impl: Implementation, methods: readonly string[]): Record<string, Function>;
+export declare function getWireRefMethods<Value>(value: Value): readonly string[] | undefined;
+export declare function wireMethodNames<Implementation extends object>(impl: Implementation): string[];
+export declare const classifyExecutionResult: WireClassifier;
+/**
+ * Bind the opaque stream channels the daemon exposes (fleet.md §4.3):
+ *   - `'pty'` on an interactive session → onOutput/write/kill.
+ *   - `'stdout'`/`'stderr'` on a spawned process → pumped ReadableStream.
+ *   - `'stdin'` on a spawned process → WritableStream writer.
+ *   - `'fs-watch'` on a filesystem/adapter watch handle → change-event stream (A8).
+ * The protocol carries the bytes; this names the methods. Any other
+ * target/channel pair has no binding (the consumer gets `NO_CHANNEL`).
+ */
+export declare const bindExecutionChannel: ChannelBinder;
+//# sourceMappingURL=execution-listen-policy.d.ts.map

package/dist/fleets/daemon/execution-listen-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-listen-policy.d.ts","sourceRoot":"","sources":["../../../src/fleets/daemon/execution-listen-policy.ts"],"names":[],"mappings":"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"}