gitd-client 0.8.0 → 0.10.0

package/dist/endpoint-types.d.ts

@@ -0,0 +1,28 @@
+/** A token of gitd's endpoint as gitd shows it, never its secret. */
+export interface TokenInfo {
+    id: string;
+    /** The repository it reads. */
+    url: string;
+    /** The sandbox repository it pushes to, when writable. */
+    sandbox: string;
+    writable: boolean;
+    issuedAt: Date;
+    expiresAt: Date;
+}
+/** A token just issued: its secret, shown this once, and where the sandbox clones from. */
+export interface IssuedToken {
+    secret: string;
+    cloneUrl: string;
+    /** The clone URL with the secret in it, for the sandbox's git: `git clone <this>`. */
+    authenticatedUrl: string;
+    info: TokenInfo;
+}
+export interface IssueTokenOptions {
+    /** The branch the sandbox starts from; default the repository's default branch. */
+    branch?: string;
+    /** How long the token lives, in seconds: an hour by default, a day at most. */
+    lifetimeSeconds?: number;
+    readOnly?: boolean;
+    /** A sandbox repository from an earlier token, to keep pushing to. */
+    sandbox?: string;
+}

package/dist/endpoint-types.js

@@ -0,0 +1 @@
+export {};

package/dist/endpoint.d.ts

@@ -0,0 +1,18 @@
+import type { Client } from "@connectrpc/connect";
+import type { EndpointService } from "./gen/gitd/v1/gitd_pb.js";
+import type { IssuedToken, IssueTokenOptions, TokenInfo } from "./endpoint-types.js";
+/**
+ * gitd's endpoint, as `gitd.endpoint`: tokens for sandboxes that clone over HTTP instead of
+ * mounting a workspace. What a sandbox pushes is published with `gitd.publish("", branch,
+ * { sandbox })`.
+ */
+export declare class Endpoint {
+    private readonly endpoint;
+    constructor(endpoint: Client<typeof EndpointService>);
+    /** A token for a sandbox: it reads url and pushes to its own sandbox repository. */
+    issue(url: string, options?: IssueTokenOptions): Promise<IssuedToken>;
+    /** Ends a token now, and removes its sandbox repository when asked. */
+    revoke(id: string, removeSandbox?: boolean): Promise<void>;
+    /** The tokens alive, never their secrets. */
+    tokens(): Promise<TokenInfo[]>;
+}

package/dist/endpoint.js

@@ -0,0 +1,49 @@
+import { timestampDate } from "@bufbuild/protobuf/wkt";
+import { call } from "./calls.js";
+/**
+ * gitd's endpoint, as `gitd.endpoint`: tokens for sandboxes that clone over HTTP instead of
+ * mounting a workspace. What a sandbox pushes is published with `gitd.publish("", branch,
+ * { sandbox })`.
+ */
+export class Endpoint {
+    endpoint;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+    }
+    /** A token for a sandbox: it reads url and pushes to its own sandbox repository. */
+    async issue(url, options = {}) {
+        const answer = await call(() => this.endpoint.issueToken({
+            url,
+            branch: options.branch ?? "",
+            lifetimeSeconds: BigInt(options.lifetimeSeconds ?? 0),
+            readOnly: options.readOnly ?? false,
+            sandbox: options.sandbox ?? "",
+        }));
+        const [scheme, rest] = answer.cloneUrl.split("://", 2);
+        return {
+            secret: answer.token,
+            cloneUrl: answer.cloneUrl,
+            authenticatedUrl: rest ? `${scheme}://x:${answer.token}@${rest}` : answer.cloneUrl,
+            info: toTokenInfo(answer.info),
+        };
+    }
+    /** Ends a token now, and removes its sandbox repository when asked. */
+    async revoke(id, removeSandbox = false) {
+        await call(() => this.endpoint.revokeToken({ id, removeSandbox }));
+    }
+    /** The tokens alive, never their secrets. */
+    async tokens() {
+        const answer = await call(() => this.endpoint.listTokens({}));
+        return answer.tokens.map(toTokenInfo);
+    }
+}
+function toTokenInfo(info) {
+    return {
+        id: info?.id ?? "",
+        url: info?.url ?? "",
+        sandbox: info?.sandbox ?? "",
+        writable: info?.writable ?? false,
+        issuedAt: info?.issuedAt ? timestampDate(info.issuedAt) : new Date(0),
+        expiresAt: info?.expiresAt ? timestampDate(info.expiresAt) : new Date(0),
+    };
+}

package/dist/gen/gitd/v1/gitd_pb.d.ts

@@ -268,7 +268,13 @@ export declare enum GitFailure_Reason {
      *
      * @generated from enum value: REASON_UNSUPPORTED = 14;
      */
-    UNSUPPORTED = 14
+    UNSUPPORTED = 14,
+    /**
+     * A limit of the tenant is reached: its workspaces, its disk or its tokens.
+     *
+     * @generated from enum value: REASON_LIMIT_REACHED = 15;
+     */
+    LIMIT_REACHED = 15
 }
 /**
  * Describes the enum gitd.v1.GitFailure.Reason.
@@ -328,6 +334,15 @@ export type PrepareRequest = Message<"gitd.v1.PrepareRequest"> & {
      * @generated from field: string warm = 8;
      */
     warm: string;
+    /**
+     * The workspace names its pool by a path inside itself, `.git/gitd-pool`, where whoever
+     * mounts the workspace elsewhere — the CSI driver into a pod — mounts the pool's objects
+     * read-only (WorkspaceResult.pool_objects), so that it works wherever it is mounted. gitd
+     * accepts it only while that is truly the pool's objects directory, mounted there.
+     *
+     * @generated from field: bool pool_inside = 9;
+     */
+    poolInside: boolean;
 };
 /**
  * Describes the message gitd.v1.PrepareRequest.
@@ -428,6 +443,13 @@ export type WorkspaceResult = Message<"gitd.v1.WorkspaceResult"> & {
      * @generated from field: repeated string lfs_patterns = 6;
      */
     lfsPatterns: string[];
+    /**
+     * With pool_inside: the pool's objects directory, to mount read-only at the workspace's
+     * `.git/gitd-pool`.
+     *
+     * @generated from field: string pool_objects = 7;
+     */
+    poolObjects: string;
 };
 /**
  * Describes the message gitd.v1.WorkspaceResult.
@@ -917,6 +939,14 @@ export type PublishRequest = Message<"gitd.v1.PublishRequest"> & {
      * @generated from field: gitd.v1.Provenance provenance = 6;
      */
     provenance?: Provenance | undefined;
+    /**
+     * Publish what a sandbox pushed through the endpoint instead of a workspace: the ID of
+     * its sandbox repository, with path left empty. branch names the branch it pushed there,
+     * published under the same name.
+     *
+     * @generated from field: string sandbox = 7;
+     */
+    sandbox: string;
 };
 /**
  * Describes the message gitd.v1.PublishRequest.
@@ -1783,6 +1813,12 @@ export type AuditEntry = Message<"gitd.v1.AuditEntry"> & {
      * @generated from field: gitd.v1.Provenance provenance = 12;
      */
     provenance?: Provenance | undefined;
+    /**
+     * The sandbox repository published from, when it was not a workspace.
+     *
+     * @generated from field: string sandbox = 13;
+     */
+    sandbox: string;
 };
 /**
  * Describes the message gitd.v1.AuditEntry.
@@ -1800,7 +1836,7 @@ export type ConfigurationChange = Message<"gitd.v1.ConfigurationChange"> & {
      */
     action: ConfigurationChange_Action;
     /**
-     * The connection's ID, the settings' prefix, or the preset's name.
+     * The connection's ID, the settings' prefix, the preset's name, or the token's ID.
      *
      * @generated from field: string subject = 2;
      */
@@ -1848,7 +1884,15 @@ export declare enum ConfigurationChange_Action {
     /**
      * @generated from enum value: ACTION_PRESET_REMOVED = 6;
      */
-    PRESET_REMOVED = 6
+    PRESET_REMOVED = 6,
+    /**
+     * @generated from enum value: ACTION_TOKEN_ISSUED = 7;
+     */
+    TOKEN_ISSUED = 7,
+    /**
+     * @generated from enum value: ACTION_TOKEN_REVOKED = 8;
+     */
+    TOKEN_REVOKED = 8
 }
 /**
  * Describes the enum gitd.v1.ConfigurationChange.Action.
@@ -2600,6 +2644,159 @@ export type RemovePresetResponse = Message<"gitd.v1.RemovePresetResponse"> & {};
  * Use `create(RemovePresetResponseSchema)` to create a new message.
  */
 export declare const RemovePresetResponseSchema: GenMessage<RemovePresetResponse>;
+/**
+ * @generated from message gitd.v1.IssueTokenRequest
+ */
+export type IssueTokenRequest = Message<"gitd.v1.IssueTokenRequest"> & {
+    /**
+     * @generated from field: string url = 1;
+     */
+    url: string;
+    /**
+     * The branch the sandbox starts from; empty for the repository's default branch.
+     *
+     * @generated from field: string branch = 2;
+     */
+    branch: string;
+    /**
+     * How long the token lives: an hour when zero, a day at most.
+     *
+     * @generated from field: int64 lifetime_seconds = 3;
+     */
+    lifetimeSeconds: bigint;
+    /**
+     * A token that clones and fetches only.
+     *
+     * @generated from field: bool read_only = 4;
+     */
+    readOnly: boolean;
+    /**
+     * A sandbox repository the token writes to, from an earlier token; empty makes a new one.
+     *
+     * @generated from field: string sandbox = 5;
+     */
+    sandbox: string;
+};
+/**
+ * Describes the message gitd.v1.IssueTokenRequest.
+ * Use `create(IssueTokenRequestSchema)` to create a new message.
+ */
+export declare const IssueTokenRequestSchema: GenMessage<IssueTokenRequest>;
+/**
+ * @generated from message gitd.v1.IssueTokenResponse
+ */
+export type IssueTokenResponse = Message<"gitd.v1.IssueTokenResponse"> & {
+    /**
+     * The token, shown this once: gitd keeps only its hash.
+     *
+     * @generated from field: string token = 1;
+     */
+    token: string;
+    /**
+     * @generated from field: gitd.v1.TokenInfo info = 2;
+     */
+    info?: TokenInfo | undefined;
+    /**
+     * Where the sandbox clones from, e.g. `https://gitd.internal:9420/git/github.com/acme/web.git`,
+     * with the token as the password: `git clone https://x:<token>@…`.
+     *
+     * @generated from field: string clone_url = 3;
+     */
+    cloneUrl: string;
+};
+/**
+ * Describes the message gitd.v1.IssueTokenResponse.
+ * Use `create(IssueTokenResponseSchema)` to create a new message.
+ */
+export declare const IssueTokenResponseSchema: GenMessage<IssueTokenResponse>;
+/**
+ * A token as gitd shows it, never its secret.
+ *
+ * @generated from message gitd.v1.TokenInfo
+ */
+export type TokenInfo = Message<"gitd.v1.TokenInfo"> & {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: string url = 2;
+     */
+    url: string;
+    /**
+     * @generated from field: string sandbox = 3;
+     */
+    sandbox: string;
+    /**
+     * @generated from field: bool writable = 4;
+     */
+    writable: boolean;
+    /**
+     * @generated from field: google.protobuf.Timestamp issued_at = 5;
+     */
+    issuedAt?: Timestamp | undefined;
+    /**
+     * @generated from field: google.protobuf.Timestamp expires_at = 6;
+     */
+    expiresAt?: Timestamp | undefined;
+};
+/**
+ * Describes the message gitd.v1.TokenInfo.
+ * Use `create(TokenInfoSchema)` to create a new message.
+ */
+export declare const TokenInfoSchema: GenMessage<TokenInfo>;
+/**
+ * @generated from message gitd.v1.RevokeTokenRequest
+ */
+export type RevokeTokenRequest = Message<"gitd.v1.RevokeTokenRequest"> & {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * Remove its sandbox repository too, with whatever was pushed there and not published.
+     *
+     * @generated from field: bool remove_sandbox = 2;
+     */
+    removeSandbox: boolean;
+};
+/**
+ * Describes the message gitd.v1.RevokeTokenRequest.
+ * Use `create(RevokeTokenRequestSchema)` to create a new message.
+ */
+export declare const RevokeTokenRequestSchema: GenMessage<RevokeTokenRequest>;
+/**
+ * @generated from message gitd.v1.RevokeTokenResponse
+ */
+export type RevokeTokenResponse = Message<"gitd.v1.RevokeTokenResponse"> & {};
+/**
+ * Describes the message gitd.v1.RevokeTokenResponse.
+ * Use `create(RevokeTokenResponseSchema)` to create a new message.
+ */
+export declare const RevokeTokenResponseSchema: GenMessage<RevokeTokenResponse>;
+/**
+ * @generated from message gitd.v1.ListTokensRequest
+ */
+export type ListTokensRequest = Message<"gitd.v1.ListTokensRequest"> & {};
+/**
+ * Describes the message gitd.v1.ListTokensRequest.
+ * Use `create(ListTokensRequestSchema)` to create a new message.
+ */
+export declare const ListTokensRequestSchema: GenMessage<ListTokensRequest>;
+/**
+ * @generated from message gitd.v1.ListTokensResponse
+ */
+export type ListTokensResponse = Message<"gitd.v1.ListTokensResponse"> & {
+    /**
+     * @generated from field: repeated gitd.v1.TokenInfo tokens = 1;
+     */
+    tokens: TokenInfo[];
+};
+/**
+ * Describes the message gitd.v1.ListTokensResponse.
+ * Use `create(ListTokensResponseSchema)` to create a new message.
+ */
+export declare const ListTokensResponseSchema: GenMessage<ListTokensResponse>;
 /**
  * How a workspace was made.
  *
@@ -3021,3 +3218,44 @@ export declare const PublishingService: GenService<{
         output: typeof RemovePresetResponseSchema;
     };
 }>;
+/**
+ * gitd's git endpoint, for sandboxes that cannot mount its directories — microVMs, remote
+ * sandboxes, CI runners elsewhere — and clone over HTTP instead. A token of gitd's own opens
+ * one repository for reading and one sandbox repository for writing; it is never the git
+ * host's credential. What a sandbox pushed is published with Publish and `sandbox`.
+ *
+ * @generated from service gitd.v1.EndpointService
+ */
+export declare const EndpointService: GenService<{
+    /**
+     * A token for a sandbox, with the address it clones from. The repository's pool is
+     * synced first, with the credential gitd keeps.
+     *
+     * @generated from rpc gitd.v1.EndpointService.IssueToken
+     */
+    issueToken: {
+        methodKind: "unary";
+        input: typeof IssueTokenRequestSchema;
+        output: typeof IssueTokenResponseSchema;
+    };
+    /**
+     * End a token now, and remove its sandbox repository when asked.
+     *
+     * @generated from rpc gitd.v1.EndpointService.RevokeToken
+     */
+    revokeToken: {
+        methodKind: "unary";
+        input: typeof RevokeTokenRequestSchema;
+        output: typeof RevokeTokenResponseSchema;
+    };
+    /**
+     * The tokens alive, never their secrets.
+     *
+     * @generated from rpc gitd.v1.EndpointService.ListTokens
+     */
+    listTokens: {
+        methodKind: "unary";
+        input: typeof ListTokensRequestSchema;
+        output: typeof ListTokensResponseSchema;
+    };
+}>;

package/dist/gen/gitd/v1/gitd_pb.js

@@ -6,7 +6,7 @@ import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt";
 /**
  * Describes the file gitd/v1/gitd.proto.
  */
-export const file_gitd_v1_gitd = /*@__PURE__*/ fileDesc("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", [file_google_protobuf_timestamp]);
+export const file_gitd_v1_gitd = /*@__PURE__*/ fileDesc("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", [file_google_protobuf_timestamp]);
 /**
  * Describes the message gitd.v1.Credential.
  * Use `create(CredentialSchema)` to create a new message.
@@ -114,6 +114,12 @@ export var GitFailure_Reason;
      * @generated from enum value: REASON_UNSUPPORTED = 14;
      */
     GitFailure_Reason[GitFailure_Reason["UNSUPPORTED"] = 14] = "UNSUPPORTED";
+    /**
+     * A limit of the tenant is reached: its workspaces, its disk or its tokens.
+     *
+     * @generated from enum value: REASON_LIMIT_REACHED = 15;
+     */
+    GitFailure_Reason[GitFailure_Reason["LIMIT_REACHED"] = 15] = "LIMIT_REACHED";
 })(GitFailure_Reason || (GitFailure_Reason = {}));
 /**
  * Describes the enum gitd.v1.GitFailure.Reason.
@@ -507,6 +513,14 @@ export var ConfigurationChange_Action;
      * @generated from enum value: ACTION_PRESET_REMOVED = 6;
      */
     ConfigurationChange_Action[ConfigurationChange_Action["PRESET_REMOVED"] = 6] = "PRESET_REMOVED";
+    /**
+     * @generated from enum value: ACTION_TOKEN_ISSUED = 7;
+     */
+    ConfigurationChange_Action[ConfigurationChange_Action["TOKEN_ISSUED"] = 7] = "TOKEN_ISSUED";
+    /**
+     * @generated from enum value: ACTION_TOKEN_REVOKED = 8;
+     */
+    ConfigurationChange_Action[ConfigurationChange_Action["TOKEN_REVOKED"] = 8] = "TOKEN_REVOKED";
 })(ConfigurationChange_Action || (ConfigurationChange_Action = {}));
 /**
  * Describes the enum gitd.v1.ConfigurationChange.Action.
@@ -758,6 +772,41 @@ export const RemovePresetRequestSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_
  * Use `create(RemovePresetResponseSchema)` to create a new message.
  */
 export const RemovePresetResponseSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 89);
+/**
+ * Describes the message gitd.v1.IssueTokenRequest.
+ * Use `create(IssueTokenRequestSchema)` to create a new message.
+ */
+export const IssueTokenRequestSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 90);
+/**
+ * Describes the message gitd.v1.IssueTokenResponse.
+ * Use `create(IssueTokenResponseSchema)` to create a new message.
+ */
+export const IssueTokenResponseSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 91);
+/**
+ * Describes the message gitd.v1.TokenInfo.
+ * Use `create(TokenInfoSchema)` to create a new message.
+ */
+export const TokenInfoSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 92);
+/**
+ * Describes the message gitd.v1.RevokeTokenRequest.
+ * Use `create(RevokeTokenRequestSchema)` to create a new message.
+ */
+export const RevokeTokenRequestSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 93);
+/**
+ * Describes the message gitd.v1.RevokeTokenResponse.
+ * Use `create(RevokeTokenResponseSchema)` to create a new message.
+ */
+export const RevokeTokenResponseSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 94);
+/**
+ * Describes the message gitd.v1.ListTokensRequest.
+ * Use `create(ListTokensRequestSchema)` to create a new message.
+ */
+export const ListTokensRequestSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 95);
+/**
+ * Describes the message gitd.v1.ListTokensResponse.
+ * Use `create(ListTokensResponseSchema)` to create a new message.
+ */
+export const ListTokensResponseSchema = /*@__PURE__*/ messageDesc(file_gitd_v1_gitd, 96);
 /**
  * How a workspace was made.
  *
@@ -824,3 +873,12 @@ export const ConnectionService = /*@__PURE__*/ serviceDesc(file_gitd_v1_gitd, 3)
  * @generated from service gitd.v1.PublishingService
  */
 export const PublishingService = /*@__PURE__*/ serviceDesc(file_gitd_v1_gitd, 4);
+/**
+ * gitd's git endpoint, for sandboxes that cannot mount its directories — microVMs, remote
+ * sandboxes, CI runners elsewhere — and clone over HTTP instead. A token of gitd's own opens
+ * one repository for reading and one sandbox repository for writing; it is never the git
+ * host's credential. What a sandbox pushed is published with Publish and `sandbox`.
+ *
+ * @generated from service gitd.v1.EndpointService
+ */
+export const EndpointService = /*@__PURE__*/ serviceDesc(file_gitd_v1_gitd, 5);

package/dist/gitd.d.ts

@@ -1,11 +1,21 @@
 import { type Transport } from "@connectrpc/connect";
 import { Credentials } from "./credentials.js";
+import { Endpoint } from "./endpoint.js";
 import { Publishing } from "./publishing.js";
 import type { PublishOptions } from "./publishing-types.js";
 import type { AuditEntry, AuditOptions, Changes, CheckoutOptions, CompareOptions, Comparison, Conflict, Description, Diff, DiffOptions, Info, PrepareOptions, Probe, Published, Side, WorkspaceEvent, UpdateOptions, WarmLayer, Workspace } from "./types.js";
 export interface GitdOptions {
     /** gitd's Unix socket; default $GITD_SOCKET, then /run/gitd/gitd.sock. */
     socket?: string;
+    /**
+     * A gitd on the network instead, e.g. `https://gitd.internal:9420` (or http:// on a private
+     * network); default $GITD_URL.
+     */
+    url?: string;
+    /** The key naming your tenant; default the file $GITD_KEY_FILE names, then $GITD_KEY. */
+    key?: string;
+    /** The PEM of a certificate authority the system does not trust; default $GITD_CA_FILE's. */
+    ca?: string;
     /** A transport of your own instead, e.g. for tests. */
     transport?: Transport;
 }
@@ -19,6 +29,8 @@ export declare class Gitd {
     readonly credentials: Credentials;
     /** The rules publishing follows, per repository prefix. */
     readonly publishing: Publishing;
+    /** Tokens of gitd's endpoint, for sandboxes elsewhere. */
+    readonly endpoint: Endpoint;
     private readonly workspaces;
     private readonly repositories;
     private readonly server;

package/dist/gitd.js

@@ -1,12 +1,14 @@
 import { timestampFromDate } from "@bufbuild/protobuf/wkt";
 import { createClient } from "@connectrpc/connect";
+import { readFileSync } from "node:fs";
 import { createConnectTransport } from "@connectrpc/connect-node";
-import { ConnectionService, PublishingService, RepositoryService, ServerService, WorkspaceService, } from "./gen/gitd/v1/gitd_pb.js";
+import { ConnectionService, EndpointService, PublishingService, RepositoryService, ServerService, WorkspaceService, } from "./gen/gitd/v1/gitd_pb.js";
 import { call, drain } from "./calls.js";
 import { sideProto, toEvent, toSide } from "./compare-convert.js";
 import { toWarmLayer } from "./warm-convert.js";
 import { refusal } from "./errors.js";
 import { Credentials } from "./credentials.js";
+import { Endpoint } from "./endpoint.js";
 import { pullRequestOptionsProto } from "./publishing-convert.js";
 import { Publishing } from "./publishing.js";
 import { accessName, publishedOf, revisionOf, strategyName, strategyProto, toAuditEntry, toChangedFiles, toChanges, toWorkspace, } from "./convert.js";
@@ -21,16 +23,19 @@ export class Gitd {
     credentials;
     /** The rules publishing follows, per repository prefix. */
     publishing;
+    /** Tokens of gitd's endpoint, for sandboxes elsewhere. */
+    endpoint;
     workspaces;
     repositories;
     server;
     constructor(options = {}) {
-        const transport = options.transport ?? socketTransport(options.socket);
+        const transport = options.transport ?? transportFor(options);
         this.workspaces = createClient(WorkspaceService, transport);
         this.repositories = createClient(RepositoryService, transport);
         this.server = createClient(ServerService, transport);
         this.credentials = new Credentials(createClient(ConnectionService, transport));
         this.publishing = new Publishing(createClient(PublishingService, transport));
+        this.endpoint = new Endpoint(createClient(EndpointService, transport));
     }
     /** Which gitd answers, and how it makes workspaces here and why. */
     async info() {
@@ -109,6 +114,7 @@ export class Gitd {
             path,
             branch,
             requestedBy: options.requestedBy ?? "",
+            sandbox: options.sandbox ?? "",
             pullRequest: pullRequestOptionsProto(options.pullRequest),
             provenance: options.provenance && {
                 agent: options.provenance.agent ?? "",
@@ -197,10 +203,39 @@ export class Gitd {
         await call(() => this.workspaces.remove({ path }));
     }
 }
-function socketTransport(socket) {
+/** The way to the gitd options name: its network address, else its socket, with the key. */
+function transportFor(options) {
+    const key = options.key ?? keyFromEnvironment();
+    const interceptors = key
+        ? [
+            (next) => async (request) => {
+                request.header.set("Authorization", `Bearer ${key}`);
+                return next(request);
+            },
+        ]
+        : [];
+    const url = options.url ?? process.env.GITD_URL;
+    if (url) {
+        const caFile = process.env.GITD_CA_FILE;
+        const ca = options.ca ?? (caFile ? readFileSync(caFile, "utf8") : undefined);
+        return createConnectTransport({
+            baseUrl: url.replace(/\/$/, ""),
+            httpVersion: "1.1",
+            interceptors,
+            nodeOptions: ca ? { ca } : {},
+        });
+    }
     return createConnectTransport({
         baseUrl: "http://gitd",
         httpVersion: "1.1",
-        nodeOptions: { socketPath: socket ?? process.env.GITD_SOCKET ?? defaultSocket },
+        interceptors,
+        nodeOptions: { socketPath: options.socket ?? process.env.GITD_SOCKET ?? defaultSocket },
     });
 }
+function keyFromEnvironment() {
+    const file = process.env.GITD_KEY_FILE;
+    if (file) {
+        return readFileSync(file, "utf8").trim();
+    }
+    return process.env.GITD_KEY?.trim() || undefined;
+}

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export { Gitd, type GitdOptions } from "./gitd.js";
 export { GitdError } from "./errors.js";
 export { Credentials } from "./credentials.js";
 export { Publishing } from "./publishing.js";
+export { Endpoint } from "./endpoint.js";
+export type * from "./endpoint-types.js";
 export type * from "./types.js";
 export type * from "./credential-types.js";
 export type * from "./publishing-types.js";

package/dist/index.js

@@ -2,4 +2,5 @@ export { Gitd } from "./gitd.js";
 export { GitdError } from "./errors.js";
 export { Credentials } from "./credentials.js";
 export { Publishing } from "./publishing.js";
+export { Endpoint } from "./endpoint.js";
 export * as proto from "./gen/gitd/v1/gitd_pb.js";

package/dist/publishing-types.d.ts

@@ -62,6 +62,8 @@ export interface PublishOptions {
     requestedBy?: string;
     pullRequest?: PullRequestOptions;
     provenance?: Provenance;
+    /** Publish what a sandbox pushed through the endpoint instead of a workspace; path is then "". */
+    sandbox?: string;
 }
 /** A pull request gitd opened. */
 export interface OpenedPullRequest {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitd-client",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Client for gitd: instant, secretless git checkouts for agent sandboxes",
   "license": "Apache-2.0",
   "repository": {