just-git 1.4.2 → 1.5.1

package/dist/server/index.d.ts

@@ -126,6 +126,20 @@ interface Storage {
      * The adapter uses this for compare-and-swap with symref resolution.
      */
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => MaybeAsync<T>): MaybeAsync<T>;
+    /**
+     * Record a fork relationship. `targetId` becomes a fork of `sourceId`.
+     * The adapter layer handles ref copying and root resolution.
+     */
+    forkRepo?(sourceId: string, targetId: string): MaybeAsync<void>;
+    /**
+     * Get the parent (root) repo ID for a fork, or `null` if the repo
+     * is not a fork.
+     */
+    getForkParent?(repoId: string): MaybeAsync<string | null>;
+    /**
+     * List all direct fork IDs of a repo.
+     */
+    listForks?(repoId: string): MaybeAsync<string[]>;
 }
 
 /** Options for {@link gcRepo}. */
@@ -336,6 +350,47 @@ interface GitServerConfig<A = Auth> {
         /** Delta window size (default 10). Smaller = faster, worse compression ratio. */
         deltaWindow?: number;
     };
+    /**
+     * Safety limits for incoming receive-pack requests.
+     *
+     * These bounds are enforced on buffered HTTP bodies and on pack ingestion
+     * for both HTTP and SSH push paths.
+     */
+    receiveLimits?: {
+        /** Maximum compressed/raw HTTP request body size in bytes. */
+        maxRequestBytes?: number;
+        /**
+         * Maximum decompressed HTTP request body size in bytes.
+         *
+         * Guards against gzip decompression bombs (`Content-Encoding: gzip`).
+         * Only applies to HTTP — SSH has no application-layer compression,
+         * so `maxRequestBytes` alone is sufficient there.
+         */
+        maxInflatedBytes?: number;
+        /** Maximum pack payload size in bytes. */
+        maxPackBytes?: number;
+        /** Maximum number of objects declared by a received pack. */
+        maxPackObjects?: number;
+    };
+    /**
+     * Safety limits for incoming upload-pack (fetch/clone) requests.
+     *
+     * Upload-pack request bodies contain only pkt-line want/have lists,
+     * so they are much smaller than receive-pack bodies. Defaults are
+     * tighter than receiveLimits (10 MB raw, 20 MB inflated).
+     */
+    fetchLimits?: {
+        /** Maximum compressed/raw HTTP request body size in bytes. */
+        maxRequestBytes?: number;
+        /**
+         * Maximum decompressed HTTP request body size in bytes.
+         *
+         * Guards against gzip decompression bombs (`Content-Encoding: gzip`).
+         * Only applies to HTTP — SSH has no application-layer compression,
+         * so `maxRequestBytes` alone is sufficient there.
+         */
+        maxInflatedBytes?: number;
+    };
     /**
      * Called when the server catches an unhandled error.
      *
@@ -474,8 +529,24 @@ interface GitServer<A = Auth> {
     repo(id: string): Promise<GitRepo | null>;
     /** Get a repo by ID, or throw if it doesn't exist. */
     requireRepo(id: string): Promise<GitRepo>;
-    /** Delete a repo and all its data. */
+    /** Delete a repo and all its data. Throws if the repo has active forks. */
     deleteRepo(id: string): Promise<void>;
+    /**
+     * Fork an existing repo. Copies refs from the source repo to the
+     * target. The fork shares the source's object pool — object reads
+     * fall through to the root repo's partition, while writes go to
+     * the fork's own partition.
+     *
+     * Forking a fork resolves to the root: `forkRepo("fork-of-A", "B")`
+     * records B as a fork of A's root, not of the intermediate fork.
+     *
+     * Requires a storage backend that implements fork methods.
+     *
+     * @throws If the source doesn't exist, the target already exists,
+     *   the storage backend doesn't support forks, or the server is
+     *   shutting down.
+     */
+    forkRepo(sourceId: string, targetId: string, options?: CreateRepoOptions): Promise<GitRepo>;
     /**
      * Remove unreachable objects from a repo's storage.
      *
@@ -873,37 +944,52 @@ interface UploadPackOptions {
     /** Delta window size (default 10). Ignored when noDelta is true. */
     deltaWindow?: number;
 }
+interface AuthorizedFetchSet {
+    allowedRefHashes: Map<string, string>;
+    allowedWantHashes: Set<string>;
+}
+interface ReceivePackLimitOptions {
+    maxPackBytes?: number;
+    maxPackObjects?: number;
+}
 /**
  * Handle a `POST /git-upload-pack` request.
  *
  * Returns `Uint8Array` for buffered responses (cache hits, deltified packs)
  * or `ReadableStream<Uint8Array>` for streaming no-delta responses.
  */
-declare function handleUploadPack(repo: GitRepo, requestBody: Uint8Array, options?: UploadPackOptions): Promise<Uint8Array | ReadableStream<Uint8Array>>;
+declare function handleUploadPack(repo: GitRepo, requestBody: Uint8Array, options?: UploadPackOptions & {
+    authorizedFetchSet?: AuthorizedFetchSet;
+}): Promise<Uint8Array | ReadableStream<Uint8Array> | Rejection>;
 interface ReceivePackResult {
     updates: RefUpdate[];
     unpackOk: boolean;
     capabilities: string[];
     /** Whether the request body contained a valid pkt-line flush packet. */
     sawFlush: boolean;
+    /** Hashes of objects ingested from the pack (for rollback on hook rejection). Only populated when the object store supports deferred ingestion (server-backed stores). Undefined for VFS-backed stores. */
+    ingestedHashes?: string[];
 }
 /**
  * Ingest a receive-pack request: parse commands, ingest the packfile,
  * and compute enriched RefUpdate objects. Does NOT apply ref updates —
  * call `applyReceivePack` to run hooks and apply refs.
+ *
+ * Objects are persisted immediately (needed by `buildRefUpdates` for
+ * ancestry checks). If hooks later reject the push, `applyReceivePack`
+ * rolls back the ingested objects.
  */
-declare function ingestReceivePack(repo: GitRepo, requestBody: Uint8Array): Promise<ReceivePackResult>;
+declare function ingestReceivePack(repo: GitRepo, requestBody: Uint8Array, limits?: ReceivePackLimitOptions): Promise<ReceivePackResult>;
 /**
  * Streaming variant of `ingestReceivePack`. Accepts pre-parsed push
- * commands and a raw pack byte stream. Uses `readPackStreaming` →
- * `ingestPackStream` so pack bytes are consumed incrementally without
- * buffering the entire pack in memory.
+ * commands and a raw pack byte stream. Uses `readPackStreaming` for
+ * incremental consumption.
  *
  * The HTTP handler continues using `ingestReceivePack` (runtime buffers
  * POST bodies anyway). The SSH handler calls this directly after parsing
  * pkt-line commands.
  */
-declare function ingestReceivePackFromStream(repo: GitRepo, commands: PushCommand[], capabilities: string[], packStream: AsyncIterable<Uint8Array>, sawFlush?: boolean): Promise<ReceivePackResult>;
+declare function ingestReceivePackFromStream(repo: GitRepo, commands: PushCommand[], capabilities: string[], packStream: AsyncIterable<Uint8Array>, sawFlush?: boolean, limits?: ReceivePackLimitOptions): Promise<ReceivePackResult>;
 /**
  * Apply ref updates with CAS protection only — no hooks.
  *
@@ -949,7 +1035,9 @@ declare function handleLsRefs<A>(repo: GitRepo, repoId: string, args: string[],
  * enumeration and pack building via the shared pipeline, then
  * builds a v2 section-based response.
  */
-declare function handleV2Fetch(repo: GitRepo, args: string[], options?: UploadPackOptions): Promise<Uint8Array | ReadableStream<Uint8Array>>;
+declare function handleV2Fetch(repo: GitRepo, args: string[], options?: UploadPackOptions & {
+    authorizedFetchSet?: AuthorizedFetchSet;
+}): Promise<Uint8Array | ReadableStream<Uint8Array> | Rejection>;
 
 /**
  * In-memory storage backend with multi-repo support.
@@ -967,6 +1055,7 @@ declare class MemoryStorage implements Storage {
     private repos;
     private objects;
     private refs;
+    private forks;
     hasRepo(repoId: string): boolean;
     insertRepo(repoId: string): void;
     deleteRepo(repoId: string): void;
@@ -986,6 +1075,9 @@ declare class MemoryStorage implements Storage {
     removeRef(repoId: string, name: string): void;
     listRefs(repoId: string, prefix?: string): RawRefEntry[];
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => T): T;
+    forkRepo(sourceId: string, targetId: string): void;
+    getForkParent(repoId: string): string | null;
+    listForks(repoId: string): string[];
     /** List all created repo IDs. Convenience for tests and debugging. */
     repoIds(): string[];
     private getObjMap;
@@ -1037,6 +1129,9 @@ declare class BunSqliteStorage implements Storage {
     removeRef(repoId: string, name: string): void;
     listRefs(repoId: string, prefix?: string): RawRefEntry[];
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => T): T;
+    forkRepo(sourceId: string, targetId: string): void;
+    getForkParent(repoId: string): string | null;
+    listForks(repoId: string): string[];
 }
 
 /** Minimal prepared statement interface matching `better-sqlite3`. */
@@ -1084,6 +1179,9 @@ declare class BetterSqlite3Storage implements Storage {
     removeRef(repoId: string, name: string): void;
     listRefs(repoId: string, prefix?: string): RawRefEntry[];
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => T): T;
+    forkRepo(sourceId: string, targetId: string): void;
+    getForkParent(repoId: string): string | null;
+    listForks(repoId: string): string[];
 }
 
 /** Minimal pool interface matching the `pg` package's `Pool` class. */
@@ -1134,6 +1232,9 @@ declare class PgStorage implements Storage {
     removeRef(repoId: string, name: string): Promise<void>;
     listRefs(repoId: string, prefix?: string): Promise<RawRefEntry[]>;
     atomicRefUpdate<T>(repoId: string, fn: (ops: RefOps) => Promise<T> | T): Promise<T>;
+    forkRepo(sourceId: string, targetId: string): Promise<void>;
+    getForkParent(repoId: string): Promise<string | null>;
+    listForks(repoId: string): Promise<string[]>;
 }
 
 export { type AdvertiseRefsEvent, type AdvertiseResult, type ApplyReceivePackOptions, type Auth, type AuthProvider, type BetterSqlite3Database, BetterSqlite3Storage, type BunSqliteDatabase, BunSqliteStorage, type CreateRepoOptions, type GcOptions, type GcResult, GitRepo, type GitServer, type GitServerConfig, type MaybeAsync, MemoryStorage, type NodeHttpRequest, type NodeHttpResponse, type PgPool, PgStorage, type PostReceiveEvent, type PreReceiveEvent, type PushCommand, RawObject, type RawRefEntry, type ReceivePackResult, Ref, type RefAdvertisement, type RefOps, type RefResult, type RefUpdate, type RefUpdateRequest, type RefUpdateResult, Rejection, type ServerHooks, type ServerPolicy, type SshChannel, type SshSessionInfo, type Storage, type UpdateEvent, type V2CommandRequest, type V2FetchRequest, type V2FetchResponseOptions, type V2LsRefsRef, advertiseRefsWithHooks, applyCasRefUpdates, applyReceivePack, buildRefAdvertisementBytes, buildRefListBytes, buildRefListPktLines, buildV2CapabilityAdvertisement, buildV2CapabilityAdvertisementBytes, buildV2FetchResponse, buildV2LsRefsResponse, collectRefs, composeHooks, createServer, handleLsRefs, handleUploadPack, handleV2Fetch, ingestReceivePack, ingestReceivePackFromStream, parseV2CommandRequest, parseV2FetchArgs, resolveRefUpdates };