@foss.global/gitmanager 1.7.1 → 2.0.0

package/ts/classes.repositoryservice.ts

@@ -3,6 +3,7 @@ import type {
   IGitManagerRepositoryServiceRequest,
   IGitManagerRepositoryServiceResult,
   IRustGitManagerRepositoryServiceDescriptor,
+  TGitManagerRepositoryServiceFailure,
 } from './models.js';
 
 class ByteLimitTransform extends plugins.stream.Transform {
@@ -11,7 +12,7 @@ class ByteLimitTransform extends plugins.stream.Transform {
   constructor(
     private readonly maximumBytes: number,
     private readonly label: string,
-    private readonly onLimit: (errorArg: Error) => void,
+    private readonly onLimit: () => void,
   ) {
     super();
   }
@@ -28,9 +29,8 @@ class ByteLimitTransform extends plugins.stream.Transform {
         : Buffer.from(chunkArg);
     this.bytes += chunk.byteLength;
     if (!Number.isSafeInteger(this.bytes) || this.bytes > this.maximumBytes) {
-      const error = new Error(this.label + ' exceeded the configured size limit');
-      this.onLimit(error);
-      callbackArg(error);
+      this.onLimit();
+      callbackArg(new Error(this.label + ' exceeded the configured size limit'));
       return;
     }
     callbackArg(null, chunk);
@@ -82,6 +82,7 @@ export class GitManagerRepositoryService {
   public readonly completed: Promise<IGitManagerRepositoryServiceResult>;
   private readonly child: plugins.childProcess.ChildProcessWithoutNullStreams;
   private completionSettled = false;
+  private failure: TGitManagerRepositoryServiceFailure | null = null;
   private timeout?: NodeJS.Timeout;
 
   constructor(
@@ -134,25 +135,31 @@ export class GitManagerRepositoryService {
       stdio: ['pipe', 'pipe', 'pipe'],
       windowsHide: true,
     });
-    const fail = (errorArg: Error) => {
-      this.terminate();
-      return errorArg;
-    };
+    const failWith = (failureArg: TGitManagerRepositoryServiceFailure) =>
+      () => this.fail(failureArg);
     const input = new ByteLimitTransform(
       descriptorArg.maxRequestBytes,
       'Git repository service request',
-      fail,
+      failWith('requestLimitExceeded'),
     );
     const output = new ByteLimitTransform(
       descriptorArg.maxResponseBytes,
       'Git repository service response',
-      fail,
+      failWith('responseLimitExceeded'),
     );
     const stderr = new ByteLimitTransform(
       128 * 1024,
       'Git repository service stderr',
-      fail,
+      failWith('stderrLimitExceeded'),
     );
+    // The service owns every stream error: a consumer's pipe() into stdin
+    // would otherwise rethrow an unhandled error. Failures surface through
+    // `completed`. Git closing its stdin early is reported by its exit
+    // status, so write errors on the child's stdin end only the pipe.
+    for (const ownedStream of [input, output, stderr, this.child.stdout, this.child.stderr]) {
+      ownedStream.on('error', failWith('streamFailed'));
+    }
+    this.child.stdin.on('error', () => undefined);
     input.pipe(this.child.stdin);
     this.child.stdout.pipe(output);
     this.child.stderr.pipe(stderr);
@@ -173,11 +180,12 @@ export class GitManagerRepositoryService {
         resolve({
           exitCode,
           signal: signal as NodeJS.Signals | null,
+          failure: this.failure,
         });
       });
     });
     this.timeout = setTimeout(() => {
-      this.terminate();
+      this.fail('processTimeout');
     }, descriptorArg.processTimeoutMs);
     this.timeout.unref();
   }
@@ -198,12 +206,33 @@ export class GitManagerRepositoryService {
     this.child.kill('SIGKILL');
   }
 
+  /**
+   * Kills the Git process tree and releases every stream, including output
+   * the caller never read, so `completed` settles without depending on the
+   * caller draining it.
+   */
   public async close(): Promise<void> {
     this.stdin.destroy();
     this.terminate();
+    for (const ownedStream of [
+      this.stdout,
+      this.stderr,
+      this.child.stdout,
+      this.child.stderr,
+    ]) {
+      ownedStream.destroy();
+    }
     await this.completed.catch(() => undefined);
   }
 
+  /** Records the first failure and terminates the Git process tree. */
+  private fail(failureArg: TGitManagerRepositoryServiceFailure): void {
+    if (!this.failure && !this.completionSettled) {
+      this.failure = failureArg;
+    }
+    this.terminate();
+  }
+
   private clearTimeout(): void {
     if (this.timeout) {
       clearTimeout(this.timeout);

package/ts/models.ts

@@ -115,9 +115,26 @@ export interface IRustGitManagerRepositoryServiceDescriptor
   idleTimeoutSeconds: number;
 }
 
+/**
+ * Why GitManager terminated a repository service process. The value says the
+ * transfer was cut, not that the repository is unchanged: an SSH-style
+ * receive-pack has no receive gate, so Git updates refs as soon as it has read
+ * a complete pack, and excess bytes arriving after that cannot undo those
+ * updates. Reconcile refs from the repository after every receive-pack,
+ * whatever `failure` says.
+ */
+export type TGitManagerRepositoryServiceFailure =
+  | 'requestLimitExceeded'
+  | 'responseLimitExceeded'
+  | 'stderrLimitExceeded'
+  | 'streamFailed'
+  | 'processTimeout';
+
 export interface IGitManagerRepositoryServiceResult {
   exitCode: number | null;
   signal: NodeJS.Signals | null;
+  /** The first failure that made GitManager terminate the process; null otherwise. */
+  failure: TGitManagerRepositoryServiceFailure | null;
 }
 
 export interface IGitManagerRestoreBundleRequest
@@ -231,6 +248,9 @@ export type {
   IGitManagerMergeResult,
   IGitManagerReadFileRequest,
   IGitManagerRef,
+  IGitManagerRefHead,
+  IGitManagerRefInventoryPage,
+  IGitManagerRefInventoryStale,
   IGitManagerRefRequest,
   IGitManagerRepositoryInfo,
   IGitManagerRepositorySelector,
@@ -243,6 +263,7 @@ export type {
   TGitManagerMergeMethod,
   TGitManagerMergeStatus,
   TGitManagerObjectType,
-  TGitManagerRefType,
+  TGitManagerRefInventoryPagination,
+  TGitManagerRefInventoryResult,
   TGitManagerTreeEntryType,
 } from '@foss.global/interfaces';

package/ts/rust-gitmanager-bridge.ts

@@ -13,7 +13,6 @@ import type {
   IGitManagerMergeRequest,
   IGitManagerMergeResult,
   IGitManagerReadFileRequest,
-  IGitManagerRef,
   IGitManagerRefRequest,
   IGitManagerProtectedRefsApplyResult,
   IGitManagerSmartHttpRepositoryProtectedRefs,
@@ -34,6 +33,7 @@ import type {
   IGitManagerTreeEntry,
   IGitManagerTreeRequest,
   IRustGitManagerConfig,
+  TGitManagerRefInventoryResult,
   IRustGitManagerRepositoryServiceDescriptor,
 } from './models.js';
 
@@ -69,7 +69,7 @@ type TGitManagerCommands = {
   prepareRepositoryService: { params: IGitManagerRepositoryServiceRequest; result: IRustGitManagerRepositoryServiceDescriptor };
   restoreRepositoryBundle: { params: IGitManagerRestoreBundleRequest; result: IGitManagerRepositoryInfo };
   listRepositories: { params: Record<string, never>; result: IGitManagerRepositoryInfo[] };
-  listRefs: { params: IGitManagerRefRequest; result: IGitManagerRef[] };
+  listRefs: { params: IGitManagerRefRequest; result: TGitManagerRefInventoryResult };
   listRepositoryLfsPointers: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryLfsPointer[] };
   mergeRepository: { params: IGitManagerMergeRequest; result: IGitManagerMergeResult };
   listTree: { params: IGitManagerTreeRequest; result: IGitManagerTreeEntry[] };
@@ -278,7 +278,9 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     return this.bridge.sendCommand('listRepositories', {});
   }
 
-  public async listRefs(requestArg: IGitManagerRefRequest): Promise<IGitManagerRef[]> {
+  public async listRefs(
+    requestArg: IGitManagerRefRequest,
+  ): Promise<TGitManagerRefInventoryResult> {
     return this.bridge.sendCommand('listRefs', requestArg);
   }