@procedures/snapshot 0.10.0 → 0.12.0

package/src/procedures/snapshot/create.ts

@@ -11,9 +11,10 @@ import { tmpdir, hostname } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as tar from "tar";
 import type { ProcedureContext } from "@procedures/client";
+import { isOutsideRoot, realPathIsInside, resolveRoot } from "@procedures/fs/root";
 import { assertSnapshotName, isExcluded } from "./names.js";
 import { readPart, sha256File } from "./archive-io.js";
-import { gitText, pnpmVersion } from "./commands.js";
+import { gitCall, pnpmVersion } from "./commands.js";
 import type {
   SnapshotCreateInput,
   SnapshotCreateOutput,
@@ -49,7 +50,7 @@ export async function snapshotCreate(
     );
 
     // Get environment info
-    const environment = await getEnvironmentInfo(ctx.signal);
+    const environment = await getEnvironmentInfo(ctx.signal, ctx.fsRoot);
 
     // Create metadata
     const metadata: SnapshotMetadata = {
@@ -132,10 +133,10 @@ export async function snapshotCreate(
 /**
  * Get ecosystem repository paths from manifest
  */
-async function getEcosystemPaths(_ctx: ProcedureContext): Promise<string[]> {
+async function getEcosystemPaths(ctx: ProcedureContext): Promise<string[]> {
   // TODO: Read from ecosystem manifest
-  // For now, return current working directory
-  return [process.cwd()];
+  // For now, the root of the files under a root, else the current working directory
+  return [ctx.fsRoot ?? process.cwd()];
 }
 
 /**
@@ -152,8 +153,8 @@ async function getRepositoryInfo(
     >(["git", "status"], { cwd: repoPath });
 
     // The commit hash ("" for a repository with no commit) and the remote URL (none without "origin")
-    const commit = (await gitText(["rev-parse", "HEAD"], repoPath, ctx.signal)) ?? "";
-    const remoteUrl = await gitText(["remote", "get-url", "origin"], repoPath, ctx.signal);
+    const commit = (await gitCall<{ value: string }>(ctx, ["git", "revParse"], { cwd: repoPath }))?.value ?? "";
+    const remoteUrl = (await gitCall<{ url: string }>(ctx, ["git", "remote"], { cwd: repoPath, name: "origin" }))?.url;
 
     // Get stash count
     let stashCount = 0;
@@ -167,11 +168,13 @@ async function getRepositoryInfo(
       // No stashes
     }
 
-    // Get package name from package.json
+    // Get package name from package.json. Under a root, a package.json whose real path is outside
+    // the root (a symlink) is not read.
     let name = basename(repoPath);
     try {
       const pkgPath = join(repoPath, "package.json");
-      if (existsSync(pkgPath)) {
+      const readable = ctx.fsRoot === undefined || (await realPathIsInside(await resolveRoot(ctx.fsRoot), pkgPath));
+      if (readable && existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
         name = pkg.name || name;
       }
@@ -191,6 +194,8 @@ async function getRepositoryInfo(
       behind: result.behind,
     };
   } catch (error) {
+    // A refusal of the root is not "no repository": the repository is there, and the root refuses it
+    if (isOutsideRoot(error)) throw error;
     // Not a git repo or error
     return {
       path: repoPath,
@@ -208,11 +213,11 @@ async function getRepositoryInfo(
 /**
  * Get environment info
  */
-async function getEnvironmentInfo(signal?: AbortSignal): Promise<SnapshotMetadata["environment"]> {
+async function getEnvironmentInfo(signal?: AbortSignal, fsRoot?: string): Promise<SnapshotMetadata["environment"]> {
   return {
     os: process.platform,
     nodeVersion: process.version,
-    pnpmVersion: await pnpmVersion(signal),
+    pnpmVersion: await pnpmVersion(signal, fsRoot),
     username: process.env["USER"] || process.env["USERNAME"] || "unknown",
     hostname: hostname(),
   };
@@ -259,11 +264,14 @@ async function createArchive(
   }
   // heavy preset includes everything
 
+  // Tar reads only the listed folders from their parent. Without `follow`, it stores a symlink as
+  // a link and does not read its target: under a root, the archive has only files of the root.
   await tar.create(
     {
       gzip: gzipOpts,
       file: archivePath,
       cwd,
+      follow: false,
       // Whole path segments, and "*.ext" for file endings. (Before, `path.includes("dist")`
       // left out src/distance.ts, and "*.log" matched nothing: deep dive DATA-3.)
       filter: (path) => !isExcluded(path, excludePatterns),

package/src/procedures/snapshot/diff.ts

@@ -6,8 +6,9 @@
 
 import { existsSync } from "node:fs";
 import { basename } from "node:path";
-import { gitText } from "./commands.js";
 import type { ProcedureContext } from "@procedures/client";
+import { isOutsideRoot } from "@procedures/fs/root";
+import { gitCall } from "./commands.js";
 import type {
   SnapshotDiffInput,
   SnapshotDiffOutput,
@@ -72,7 +73,7 @@ export async function snapshotDiff(
 
     try {
       // Get current branch (a failure is an error of this repository: the catch below)
-      const currentBranch = await gitText(["rev-parse", "--abbrev-ref", "HEAD"], repoPath, ctx.signal);
+      const currentBranch = (await gitCall<{ value: string }>(ctx, ["git", "revParse"], { cwd: repoPath, abbrevRef: true }))?.value;
       if (currentBranch === undefined) throw new Error(`git cannot read the branch of ${repoPath}`);
 
       if (currentBranch !== snapshotRepo.branch) {
@@ -83,7 +84,7 @@ export async function snapshotDiff(
       }
 
       // Get current commit
-      const currentCommit = await gitText(["rev-parse", "HEAD"], repoPath, ctx.signal);
+      const currentCommit = (await gitCall<{ value: string }>(ctx, ["git", "revParse"], { cwd: repoPath }))?.value;
       if (currentCommit === undefined) throw new Error(`git cannot read the commit of ${repoPath}`);
 
       if (currentCommit !== snapshotRepo.commit) {
@@ -99,12 +100,13 @@ export async function snapshotDiff(
           if (!/^[0-9a-f]{7,64}$/i.test(snapshotRepo.commit)) {
             throw new Error(`Not a commit hash: ${snapshotRepo.commit}`);
           }
-          const diffStat = await gitText(["diff", "--stat", `${snapshotRepo.commit}..HEAD`], repoPath, ctx.signal);
-          if (diffStat === undefined) throw new Error(`git cannot compare ${snapshotRepo.commit} with HEAD`);
-          // Count lines that represent files (contain |)
-          diff.filesChanged = diffStat.split("\n").filter((l) => l.includes("|")).length;
+          const changes = await gitCall<{ files: unknown[] }>(ctx, ["git", "diff"], { cwd: repoPath, ref: `${snapshotRepo.commit}..HEAD`, stat: true });
+          if (changes === undefined) throw new Error(`git cannot compare ${snapshotRepo.commit} with HEAD`);
+          // One entry for each file that changed, also a binary file
+          diff.filesChanged = changes.files.length;
           totalFilesChanged += diff.filesChanged;
-        } catch {
+        } catch (error) {
+          if (isOutsideRoot(error)) throw error;
           // Snapshot commit may not exist locally
           diff.filesChanged = -1;
         }
@@ -126,7 +128,9 @@ export async function snapshotDiff(
       ) {
         reposChanged++;
       }
-    } catch {
+    } catch (error) {
+      // A refusal of the root is not "no repository": the repository is there, and the root refuses it
+      if (isOutsideRoot(error)) throw error;
       // Not a git repo or error
       diff.filesChanged = -1;
       reposChanged++;