@exagone313/dsh-podman 0.2.0-rc.3 → 0.2.0

package/dist/fs-provider.test.js

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 import test from "node:test";
 import assert from "node:assert/strict";
-import { editGuest, editProvider, fakeGuest, providerFor, stubResolver } from "./test-support.js";
+import { editGuest, editProvider, fakeGuest, providerFor, stubResolver, } from "./test-support.js";
 import { createFilesystemProvider } from "./index.js";
 test("filesystem provider resolves absolute safe paths", async () => {
     const provider = createFilesystemProvider(stubResolver);
@@ -71,7 +71,9 @@ test("filesystem provider lstat maps entry types without following links", async
             token: "t",
         }),
     });
-    const info = await provider.lstat("/projects/team/link", { cwd: "/projects/team" });
+    const info = await provider.lstat("/projects/team/link", {
+        cwd: "/projects/team",
+    });
     assert.equal(info.type, "symlink");
     assert.equal(info.size, 3);
     assert.deepEqual(requests, [{ path: "/projects/team/link", noFollow: true }]);
@@ -100,7 +102,8 @@ test("filesystem provider streamText decodes UTF-8 and rejects binary", async ()
         for await (const _chunk of await binary.streamText(binaryTarget)) {
             // Drain the stream so the binary sample is inspected.
         }
-    }, (error) => error instanceof Error && error.code === "FS_NOT_TEXT");
+    }, (error) => error instanceof Error &&
+        error.code === "FS_NOT_TEXT");
 });
 test("filesystem provider readBytes returns content and caps at maxBytes", async () => {
     const fake = fakeGuest(Buffer.from("hello"));
@@ -109,7 +112,8 @@ test("filesystem provider readBytes returns content and caps at maxBytes", async
     const bytes = await provider.readBytes(target, undefined, 10);
     assert.equal(Buffer.from(bytes).toString(), "hello");
     assert.equal(fake.requests[0].length, 11);
-    await assert.rejects(() => provider.readBytes(target, undefined, 3), (error) => error instanceof Error && error.code === "FS_TOO_LARGE");
+    await assert.rejects(() => provider.readBytes(target, undefined, 3), (error) => error instanceof Error &&
+        error.code === "FS_TOO_LARGE");
 });
 test("filesystem provider readByteRange returns the window and empty for zero length", async () => {
     const fake = fakeGuest(Buffer.from("abcdef"));
@@ -152,7 +156,10 @@ test("filesystem provider writeText reports the harness error codes", async () =
     const existing = editProvider(editGuest({}, Buffer.from("hello")));
     const target = await existing.resolve("/a", { cwd: "/x" });
     await assert.rejects(() => existing.writeText(target, "x", { kind: "createIfAbsent" }), (error) => error.code === "FS_NOT_OBSERVED");
-    await assert.rejects(() => existing.writeText(target, "x", { kind: "replaceIfVersion", version: "other" }), (error) => error.code === "FS_STALE_VERSION");
+    await assert.rejects(() => existing.writeText(target, "x", {
+        kind: "replaceIfVersion",
+        version: "other",
+    }), (error) => error.code === "FS_STALE_VERSION");
     const dir = editProvider(editGuest({ isDir: true }));
     const dirTarget = await dir.resolve("/a", { cwd: "/x" });
     await assert.rejects(() => dir.writeText(dirTarget, "x"), (error) => error.code === "FS_NOT_REGULAR_FILE");
@@ -215,7 +222,9 @@ test("filesystem provider listDir returns resolved child targets", async () => {
             token: "t",
         }),
     });
-    const target = await provider.resolve("/projects/team", { cwd: "/projects/team" });
+    const target = await provider.resolve("/projects/team", {
+        cwd: "/projects/team",
+    });
     const entries = await provider.listDir(target);
     assert.deepEqual(requests, [{ path: "/projects/team" }]);
     assert.deepEqual(entries.map((entry) => ({
@@ -224,9 +233,24 @@ test("filesystem provider listDir returns resolved child targets", async () => {
         path: entry.target.displayPath,
         binding: entry.target.binding.token,
     })), [
-        { name: "src", type: "directory", path: "/projects/team/src", binding: "t" },
-        { name: "a.txt", type: "file", path: "/projects/team/a.txt", binding: "t" },
-        { name: "link", type: "other", path: "/projects/team/link", binding: "t" },
+        {
+            name: "src",
+            type: "directory",
+            path: "/projects/team/src",
+            binding: "t",
+        },
+        {
+            name: "a.txt",
+            type: "file",
+            path: "/projects/team/a.txt",
+            binding: "t",
+        },
+        {
+            name: "link",
+            type: "other",
+            path: "/projects/team/link",
+            binding: "t",
+        },
     ]);
     assert.equal(entries[1].size, 3);
     assert.equal(entries[0].size, undefined);
@@ -247,7 +271,10 @@ test("filesystem provider listDir falls back to the directory bit", async () =>
     });
     const target = await provider.resolve("/w", { cwd: "/w" });
     const entries = await provider.listDir(target);
-    assert.deepEqual(entries.map((entry) => entry.type), ["directory", "file"]);
+    assert.deepEqual(entries.map((entry) => entry.type), [
+        "directory",
+        "file",
+    ]);
 });
 test("filesystem provider writeText normalizes the diff basis", async () => {
     const binding = editGuest({}, Buffer.from("a\r\nb\r\n"));
@@ -258,3 +285,17 @@ test("filesystem provider writeText normalizes the diff basis", async () => {
     assert.equal(outcome.after, "c\nd\n");
     assert.equal(Buffer.concat(binding.writes).toString(), "c\r\nd\r\n");
 });
+test("filesystem provider reports watching as unsupported", async () => {
+    const provider = createFilesystemProvider(stubResolver);
+    const target = await provider.resolve("/projects/team/app", { cwd: "/x" });
+    let notified = false;
+    await assert.rejects(() => provider.watch(target, () => {
+        notified = true;
+    }, new AbortController().signal), (error) => error.code === "FS_IO_ERROR" &&
+        error.message ===
+            "Filesystem watching is not supported by this provider.");
+    assert.equal(notified, false, "changed must not fire when watching is unsupported");
+    const aborted = new AbortController();
+    aborted.abort();
+    assert.throws(() => provider.watch(target, () => { }, aborted.signal), (error) => error.code === "FS_ABORTED");
+});

package/dist/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.2.0-rc.3";
-export declare const GIT_COMMIT = "f61b296";
+export declare const VERSION = "0.2.0";
+export declare const GIT_COMMIT = "276d50e";

package/dist/generated/version.js

@@ -2,5 +2,5 @@
 //
 // SPDX-License-Identifier: MIT
 // Generated by scripts/generate-version.mjs; do not edit.
-export const VERSION = "0.2.0-rc.3";
-export const GIT_COMMIT = "f61b296";
+export const VERSION = "0.2.0";
+export const GIT_COMMIT = "276d50e";

package/dist/grpc/proto/dshctl/v1/control.proto

@@ -7,9 +7,11 @@ package dshctl.v1;
 option go_package = "github.com/Exagone313/dsh-podman/internal/genproto/dshctl/v1;dshctlv1";
 
 service OrchestratorControl {
+  rpc GetVersion(GetVersionRequest) returns (GetVersionResponse);
   rpc ListProjects(ListProjectsRequest) returns (ListProjectsResponse);
   rpc CreateWorkspace(CreateWorkspaceRequest) returns (Workspace);
   rpc DescribeWorkspace(DescribeWorkspaceRequest) returns (Workspace);
+  rpc EnsureContainer(EnsureContainerRequest) returns (Container);
   rpc ListWorkspaces(ListWorkspacesRequest) returns (ListWorkspacesResponse);
   rpc RemoveWorkspace(RemoveWorkspaceRequest) returns (RemoveWorkspaceResponse);
   rpc ListImages(ListImagesRequest) returns (ListImagesResponse);
@@ -41,6 +43,8 @@ service OrchestratorControl {
   rpc RemoveContainerSecret(RemoveContainerSecretRequest) returns (Container);
 }
 
+message GetVersionRequest {}
+message GetVersionResponse { string version = 1; string commit = 2; }
 message ListProjectsRequest {}
 message ListProjectsResponse { repeated Project projects = 1; }
 message Project { string name = 1; string host_path = 2; }
@@ -79,6 +83,11 @@ message ListImagesResponse { repeated Image images = 1; }
 message Image { string image_id = 1; string parent = 2; repeated string packages = 3; string image_tag = 4; string built_at = 5; bool is_base = 6; string status = 7; string primitive = 8; string package_manager = 9; bool base_public = 10; }
 message RebuildImageRequest { string image_id = 1; }
 message RebuildAllImagesRequest {}
+// The images one RebuildAllImages call rebuilt or could not provide. `rebuilt`
+// names the stored custom images that were rebuilt, in dependency order; a base
+// image ensured beforehand is not listed. `skipped` names every image the call
+// could not make available: base short names first, then the custom images
+// whose rebuild failed and the images that depend on them.
 message RebuildAllImagesResponse { repeated string rebuilt = 1; repeated string skipped = 2; }
 message RemoveImageRequest { string image_id = 1; }
 message RemoveImageResponse {}
@@ -109,7 +118,8 @@ message Container {
   repeated string paths = 12;
 }
 message StartContainerRequest { string workspace_slug = 1; string container = 2; string image_id = 3; repeated ProjectMount mounts = 4; map<string, string> env = 5; map<string, string> secret_env = 6; repeated string paths = 7; }
-message RecreateContainerRequest { string workspace_slug = 1; string image_id = 2; string container = 3; repeated ProjectMount mounts = 4; map<string, string> env = 5; repeated string paths = 6; }
+message EnsureContainerRequest { string workspace_slug = 1; string container = 2; }
+message RecreateContainerRequest { string workspace_slug = 1; string image_id = 2; string container = 3; repeated ProjectMount mounts = 4; map<string, string> env = 5; repeated string paths = 6; map<string, string> secret_env = 7; }
 message RemoveContainerRequest { string workspace_slug = 1; string container = 2; }
 message RemoveContainerResponse {}
 message AddContainerMountRequest { string workspace_slug = 1; string container = 2; string project = 3; reserved 4; string destination = 5; MountMode mode = 6; MountKind kind = 7; string volume = 8; string secret = 9; }

package/dist/grpc/proto/dshguest/v1/guest.proto

@@ -9,6 +9,9 @@ option go_package = "github.com/Exagone313/dsh-podman/internal/genproto/dshguest
 import "google/protobuf/wrappers.proto";
 
 service WorkspaceGuestAgent {
+  // Ping reports that the agent is reachable and accepts the caller's
+  // credential. Callers use it as a readiness probe before issuing work.
+  rpc Ping(PingRequest) returns (PingResponse);
   rpc Exec(stream ExecInput) returns (stream ExecOutput);
   rpc Signal(SignalRequest) returns (SignalResponse);
   rpc ReadFile(ReadFileRequest) returns (stream ReadFileChunk);
@@ -27,6 +30,8 @@ service WorkspaceGuestAgent {
   rpc DaemonLogs(DaemonLogsRequest) returns (DaemonLogsResponse);
   rpc Terminal(stream TerminalInput) returns (stream TerminalOutput);
 }
+message PingRequest {}
+message PingResponse { string version = 1; string commit = 2; }
 message ExecInput { oneof payload { ExecStart start = 1; bytes stdin_chunk = 2; } }
 message ExecStart { repeated string argv = 1; string cwd = 2; map<string, string> env = 3; repeated string unset_env = 4; SpillTarget spill_stdout = 5; SpillTarget spill_stderr = 6; google.protobuf.Int32Value uid = 7; google.protobuf.Int32Value gid = 8; repeated uint32 groups = 9; bool stdin_pipe = 10; }
 message ExecOutput { oneof payload { bytes stdout_chunk = 1; bytes stderr_chunk = 2; ExecExit exit = 3; } string process_id = 4; }

package/dist/grpc/runtime-client.d.ts

@@ -1,5 +1,7 @@
 import grpc from "@grpc/grpc-js";
 export declare function controlClient(socket: string): grpc.Client;
 export declare function guestClient(socket: string): grpc.Client;
-export declare function unary<T>(client: grpc.Client, method: string, request: unknown, metadata?: grpc.Metadata): Promise<T>;
+export declare function closeClients(): void;
+export declare function abortError(label: string): Error;
+export declare function unary<T>(client: grpc.Client, method: string, request: unknown, metadata?: grpc.Metadata, signal?: AbortSignal): Promise<T>;
 export { grpc };

package/dist/grpc/runtime-client.js

@@ -7,27 +7,55 @@ import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "node:path";
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "proto");
 const definitions = new Map();
+// Live channels, keyed like the constructors: one client per service and
+// socket for the plugin's lifetime. A channel holds a unix-socket connection
+// and worker threads, so constructing one per call leaks both; the resolver
+// disposes this cache on shutdown.
+const clients = new Map();
+// Keepalive lets a half-open channel fail fast instead of leaving a call
+// pending forever, which is what backs the "hung orchestrator" symptom. Calls
+// themselves carry no deadline: several control operations (image pull/build,
+// cache clean) are legitimately long, so cancellation is driven by the turn's
+// AbortSignal instead.
+//
+// Both servers permit exactly this policy (internal/grpcopts.KeepalivePolicy);
+// grpc-go's default (5 minutes, no pings without streams) answers these pings
+// with GOAWAY "too many pings", which grpc-js logs as "rejected by server
+// because of excess pings". Keep the interval in sync with that policy.
+const CHANNEL_OPTIONS = {
+    "grpc.keepalive_time_ms": 30_000,
+    "grpc.keepalive_timeout_ms": 10_000,
+    "grpc.keepalive_permit_without_calls": 1,
+};
 function unixTarget(socket) {
     return socket.startsWith("unix:") ? socket : `unix:${socket}`;
 }
+function constructorFor(service, proto) {
+    const cached = definitions.get(service);
+    if (cached !== undefined)
+        return cached;
+    const packageDefinition = loader.loadSync(resolve(root, proto), {
+        longs: String,
+        enums: String,
+        defaults: true,
+    });
+    const loaded = grpc.loadPackageDefinition(packageDefinition);
+    const namespace = service.startsWith("dshctl")
+        ? loaded.dshctl
+        : loaded.dshguest;
+    const version = namespace.v1;
+    const Constructor = version[service.split(".").at(-1)];
+    definitions.set(service, Constructor);
+    return Constructor;
+}
 function client(service, proto, socket) {
     const key = `${service}:${socket}`;
-    let Constructor = definitions.get(key);
-    if (Constructor === undefined) {
-        const packageDefinition = loader.loadSync(resolve(root, proto), {
-            longs: String,
-            enums: String,
-            defaults: true,
-        });
-        const loaded = grpc.loadPackageDefinition(packageDefinition);
-        const namespace = service.startsWith("dshctl")
-            ? loaded.dshctl
-            : loaded.dshguest;
-        const version = namespace.v1;
-        Constructor = version[service.split(".").at(-1)];
-        definitions.set(key, Constructor);
+    let existing = clients.get(key);
+    if (existing === undefined) {
+        existing = new (constructorFor(service, proto))(unixTarget(socket), grpc.credentials.createInsecure(), CHANNEL_OPTIONS);
+        clients.set(key, existing);
     }
-    return new Constructor(unixTarget(socket), grpc.credentials.createInsecure());
+    return existing;
 }
 export function controlClient(socket) {
     return client("dshctl.v1.OrchestratorControl", "dshctl/v1/control.proto", socket);
@@ -35,9 +63,54 @@ export function controlClient(socket) {
 export function guestClient(socket) {
     return client("dshguest.v1.WorkspaceGuestAgent", "dshguest/v1/guest.proto", socket);
 }
-export function unary(client, method, request, metadata) {
+// closeClients closes and forgets every cached channel. Called when the plugin
+// is disposed; a later call would create a fresh client.
+export function closeClients() {
+    for (const client of clients.values()) {
+        client.close();
+    }
+    clients.clear();
+}
+// abortError is the stable shape an aborted call rejects with, so callers can
+// tell a cancellation apart from a transport failure without parsing text.
+export function abortError(label) {
+    const error = new Error(`${label} aborted`);
+    error.code = "ABORTED";
+    return error;
+}
+// onAbortCancel cancels a pending call when the signal aborts, and returns the
+// detach function that removes the listener once the call settles.
+function onAbortCancel(call, signal) {
+    if (signal === undefined)
+        return () => { };
+    const onAbort = () => {
+        try {
+            call.cancel();
+        }
+        catch {
+            // A finished call cannot be cancelled again; nothing to do.
+        }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    return () => signal.removeEventListener("abort", onAbort);
+}
+export function unary(client, method, request, metadata, signal) {
     return new Promise((resolvePromise, reject) => {
-        client[method](request, metadata ?? new grpc.Metadata(), (error, value) => error ? reject(error) : resolvePromise(value));
+        if (signal?.aborted) {
+            reject(abortError(method));
+            return;
+        }
+        let detach = () => { };
+        const call = client[method](request, metadata ?? new grpc.Metadata(), (error, value) => {
+            detach();
+            if (error) {
+                reject(signal?.aborted ? abortError(method) : error);
+            }
+            else {
+                resolvePromise(value);
+            }
+        });
+        detach = onAbortCancel(call, signal);
     });
 }
 export { grpc };

package/dist/guest-rpc.d.ts

@@ -1,4 +1,4 @@
-import { WorkspaceResolver } from "./workspace-binding.js";
+import { type WorkspaceBinding, WorkspaceResolver } from "./workspace-binding.js";
 export declare function resolveGuestPath(path: string, sessionCwd: unknown): string;
 export declare function resolveGuestCwd(cwd: unknown, sessionCwd: unknown): string | undefined;
 export declare function guestCwd(requested: unknown, sessionCwd: unknown, binding: {
@@ -11,6 +11,7 @@ export declare function detectLineEndings(raw: string): "CRLF" | "LF";
 export declare function restoreLineEndings(content: string, endings: "CRLF" | "LF"): string;
 export declare function fsError(code: string, message: string): Error;
 export declare function throwIfAborted(signal: AbortSignal | undefined, verb: string): void;
+export declare function withGuestAuth<T>(binding: WorkspaceBinding, run: (guest: any, token: string) => Promise<T>): Promise<T>;
 export declare function guestChunks(target: any, range: {
     offset?: number;
     length?: number;
@@ -19,42 +20,37 @@ export declare function guestTextChunks(target: any, signal: AbortSignal | undef
 export declare function readGuestText(target: any, signal: AbortSignal | undefined): Promise<string>;
 export declare function readDiffBasis(target: any, signal: AbortSignal | undefined): Promise<string | null>;
 export declare function guestVersion(result: any): string;
-export declare function writeGuestFile(binding: {
-    guest: any;
-    token: string;
-}, path: string, content: string, opts: {
+export declare function writeGuestFile(binding: WorkspaceBinding, path: string, content: string, opts: {
     create: boolean;
     truncate: boolean;
 }, signal?: AbortSignal): Promise<number>;
-export declare function readGuestFile(binding: {
-    guest: any;
-    token: string;
-}, path: string): Promise<string>;
+export declare function readGuestFile(binding: WorkspaceBinding, path: string): Promise<string>;
 export interface ExecIdentity {
     uid?: number;
     gid?: number;
     groups?: number[];
 }
-export declare function runExec(binding: {
-    guest: any;
-    token: string;
-}, argv: readonly string[], cwd?: string, env?: Record<string, string>, timeoutMs?: number, identity?: ExecIdentity): Promise<{
+export interface RunExecOptions {
+    signal?: AbortSignal;
+    maxBytes?: number;
+    spillBytes?: number;
+    killGraceMs?: number;
+}
+export declare function runExec(binding: WorkspaceBinding, argv: readonly string[], cwd?: string, env?: Record<string, string>, timeoutMs?: number, identity?: ExecIdentity, options?: RunExecOptions): Promise<{
     exitCode: number;
     signal: string | null;
     stdout: string;
     stderr: string;
+    stdoutSpillPath?: string;
+    stderrSpillPath?: string;
 }>;
 export declare function sliceLines(content: string, offset: unknown, limit: unknown): string;
+export declare function streamLines(stream: AsyncIterable<string>, offset: unknown, limit: unknown): Promise<string>;
 export declare function outputLines(text: string): string[];
 export declare function bytesText(value: unknown): string;
 export declare function currentCwd(exec: any): unknown;
 export declare function sessionWorkspaceSlug(resolver: WorkspaceResolver, cwd: unknown): Promise<string>;
-export declare function resolveToolBinding(resolver: WorkspaceResolver, cwd: unknown, container: string): Promise<{
-    guest: any;
-    token: string;
-    socket: string;
-    defaultCwd?: string;
-}>;
+export declare function resolveToolBinding(resolver: WorkspaceResolver, cwd: unknown, container: string, signal?: AbortSignal): Promise<WorkspaceBinding>;
 export declare function guestStat(target: any, signal?: AbortSignal): Promise<any>;
 export declare function guestStatResponse(target: any, signal?: AbortSignal): Promise<any>;
 export declare function unaryGuest(target: any, method: string, request: unknown, signal?: AbortSignal): Promise<unknown>;