swallowkit 1.0.0-beta.9 → 1.0.1

package/src/__tests__/cosmos-worktree-isolation.test.ts

@@ -0,0 +1,149 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  createWorktreePathHash,
+  resolveCosmosDatabaseNameForWorktree,
+  resolveGitWorktreeInfo,
+} from "../cli/commands/cosmos-worktree-isolation";
+
+describe("Cosmos DB worktree isolation", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), "swallowkit-worktree-isolation-")
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("keeps the base database name in the main worktree", () => {
+    const mainRoot = path.join(tempDir, "main");
+    const gitDir = path.join(mainRoot, ".git");
+    fs.mkdirSync(gitDir, { recursive: true });
+    const runGit = jest.fn(() => [mainRoot, gitDir, ".git"].join("\n"));
+
+    const result = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      mainRoot,
+      runGit
+    );
+
+    expect(runGit).toHaveBeenCalledWith(
+      [
+        "rev-parse",
+        "--show-toplevel",
+        "--absolute-git-dir",
+        "--git-common-dir",
+      ],
+      mainRoot
+    );
+    expect(result).toEqual({
+      databaseName: "MyAppDatabase",
+      worktreeIsolationEnabled: false,
+    });
+  });
+
+  it("adds an eight-character path hash in a linked worktree", () => {
+    const { linkedRoot, gitDir, commonDir } = createLinkedWorktreePaths("one");
+
+    const result = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      linkedRoot,
+      () => [linkedRoot, gitDir, commonDir].join("\n")
+    );
+
+    expect(result.worktreeIsolationEnabled).toBe(true);
+    expect(result.databaseName).toMatch(/^MyAppDatabase_[a-f0-9]{8}$/);
+    expect(result.databaseName).toBe(
+      `MyAppDatabase_${createWorktreePathHash(linkedRoot)}`
+    );
+  });
+
+  it("generates the same hash for repeated resolution of one worktree", () => {
+    const { linkedRoot, gitDir, commonDir } =
+      createLinkedWorktreePaths("stable");
+    const runGit = () => [linkedRoot, gitDir, commonDir].join("\n");
+
+    const first = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      linkedRoot,
+      runGit
+    );
+    const second = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      linkedRoot,
+      runGit
+    );
+
+    expect(second.databaseName).toBe(first.databaseName);
+  });
+
+  it("generates different hashes for different worktree roots", () => {
+    const firstRoot = path.join(tempDir, "linked-one");
+    const secondRoot = path.join(tempDir, "linked-two");
+    fs.mkdirSync(firstRoot);
+    fs.mkdirSync(secondRoot);
+
+    expect(createWorktreePathHash(firstRoot)).not.toBe(
+      createWorktreePathHash(secondRoot)
+    );
+  });
+
+  it("uses the worktree root when invoked from a subdirectory", () => {
+    const { linkedRoot, gitDir, commonDir } =
+      createLinkedWorktreePaths("nested");
+    const nestedDir = path.join(linkedRoot, "apps", "web");
+    fs.mkdirSync(nestedDir, { recursive: true });
+    const runGit = () => [linkedRoot, gitDir, commonDir].join("\n");
+
+    const fromRoot = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      linkedRoot,
+      runGit
+    );
+    const fromNestedDir = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      nestedDir,
+      runGit
+    );
+
+    expect(fromNestedDir.databaseName).toBe(fromRoot.databaseName);
+  });
+
+  it("falls back to the base name when Git information cannot be read", () => {
+    const result = resolveCosmosDatabaseNameForWorktree(
+      "MyAppDatabase",
+      tempDir,
+      () => {
+        throw new Error("git is unavailable");
+      }
+    );
+
+    expect(result).toEqual({
+      databaseName: "MyAppDatabase",
+      worktreeIsolationEnabled: false,
+    });
+    expect(
+      resolveGitWorktreeInfo(tempDir, () => "not enough output")
+    ).toBeNull();
+  });
+
+  function createLinkedWorktreePaths(name: string): {
+    linkedRoot: string;
+    gitDir: string;
+    commonDir: string;
+  } {
+    const mainRoot = path.join(tempDir, `main-${name}`);
+    const linkedRoot = path.join(tempDir, `linked-${name}`);
+    const commonDir = path.join(mainRoot, ".git");
+    const gitDir = path.join(commonDir, "worktrees", name);
+    fs.mkdirSync(linkedRoot, { recursive: true });
+    fs.mkdirSync(gitDir, { recursive: true });
+
+    return { linkedRoot, gitDir, commonDir };
+  }
+});

package/src/__tests__/dev-seeds.test.ts

@@ -1,13 +1,19 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
+import { CosmosClient } from "@azure/cosmos";
 import { createBasicModelInfo } from "./fixtures";
 import {
+  applyDevSeedEnvironment,
+  buildDefaultCosmosDatabaseName,
   buildSeedTemplateDocument,
   getContainerNameForModel,
   loadDevSeedFiles,
   normalizeSeedIdentifier,
+  parseCosmosConnectionString,
   parseSeedDocuments,
+  prepareSeedDocumentsForExport,
+  resolveLocalCosmosConnectionInfo,
 } from "../cli/commands/dev-seeds";
 
 describe("dev seed helpers", () => {
@@ -40,6 +46,17 @@ describe("dev seed helpers", () => {
     ]);
   });
 
+  it("builds default Cosmos database names from package names", () => {
+    expect(buildDefaultCosmosDatabaseName("swallowkit")).toBe("SwallowkitDatabase");
+  });
+
+  it("parses Cosmos DB connection strings", () => {
+    expect(parseCosmosConnectionString("AccountEndpoint=https://localhost:8081/;AccountKey=test-key==;")).toEqual({
+      endpoint: "https://localhost:8081/",
+      key: "test-key==",
+    });
+  });
+
   it("loads matching seed files for an environment", async () => {
     const seedsDir = path.join(tempDir, "dev-seeds", "local");
     fs.mkdirSync(seedsDir, { recursive: true });
@@ -71,6 +88,113 @@ describe("dev seed helpers", () => {
     await expect(loadDevSeedFiles("local", [createBasicModelInfo()])).rejects.toThrow(/non-empty string id/);
   });
 
+  it("reads local Cosmos DB settings from local.settings.json", () => {
+    const functionsDir = path.join(tempDir, "functions");
+    fs.mkdirSync(functionsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(functionsDir, "local.settings.json"),
+      JSON.stringify(
+        {
+          Values: {
+            CosmosDBConnection: "AccountEndpoint=https://localhost:8081/;AccountKey=test-key==;",
+            COSMOS_DB_DATABASE_NAME: "CustomDatabase",
+          },
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+
+    const result = resolveLocalCosmosConnectionInfo("FallbackDatabase", functionsDir);
+
+    expect(result).toEqual({
+      ok: true,
+      value: {
+        endpoint: "https://localhost:8081/",
+        key: "test-key==",
+        databaseName: "CustomDatabase",
+        worktreeIsolationEnabled: false,
+        localSettingsPath: path.join(functionsDir, "local.settings.json"),
+      },
+    });
+  });
+
+  it("uses an explicit database name as the isolated seed database in a linked worktree", async () => {
+    const functionsDir = path.join(tempDir, "functions");
+    const linkedRoot = path.join(tempDir, "linked");
+    const commonGitDir = path.join(tempDir, "main", ".git");
+    const worktreeGitDir = path.join(commonGitDir, "worktrees", "linked");
+    fs.mkdirSync(functionsDir, { recursive: true });
+    fs.mkdirSync(linkedRoot, { recursive: true });
+    fs.writeFileSync(
+      path.join(functionsDir, "local.settings.json"),
+      JSON.stringify({
+        Values: {
+          CosmosDBConnection: "AccountEndpoint=https://localhost:8081/;AccountKey=test-key==;",
+          COSMOS_DB_DATABASE_NAME: "ExplicitDatabase",
+        },
+      }),
+      "utf-8"
+    );
+
+    const connectionInfo = resolveLocalCosmosConnectionInfo("FallbackDatabase", functionsDir, {
+      cwd: linkedRoot,
+      runGit: () => [linkedRoot, worktreeGitDir, commonGitDir].join("\n"),
+    });
+
+    expect(connectionInfo.ok).toBe(true);
+    if (!connectionInfo.ok) {
+      throw new Error("Expected local Cosmos DB connection info");
+    }
+    expect(connectionInfo.value.databaseName).toMatch(/^ExplicitDatabase_[a-f0-9]{8}$/);
+    expect(connectionInfo.value.worktreeIsolationEnabled).toBe(true);
+
+    const seedsDir = path.join(tempDir, "dev-seeds", "local");
+    fs.mkdirSync(seedsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(seedsDir, "todo.json"),
+      JSON.stringify([{ id: "todo-001", title: "Isolated" }]),
+      "utf-8"
+    );
+
+    const createItem = jest.fn(async () => undefined);
+    const container = {
+      delete: jest.fn(async () => undefined),
+      items: { create: createItem },
+    };
+    const database = {
+      container: jest.fn(() => container),
+      containers: { createIfNotExists: jest.fn(async () => undefined) },
+    };
+    const client = { database: jest.fn(() => database) } as unknown as CosmosClient;
+
+    await applyDevSeedEnvironment({
+      client,
+      databaseName: connectionInfo.value.databaseName,
+      environment: "local",
+      models: [createBasicModelInfo()],
+    });
+
+    expect(client.database).toHaveBeenCalledWith(connectionInfo.value.databaseName);
+    expect(createItem).toHaveBeenCalledWith({ id: "todo-001", title: "Isolated" });
+  });
+
+  it("prepares exported seed documents by removing Cosmos metadata and sorting ids", () => {
+    expect(
+      prepareSeedDocumentsForExport(
+        [
+          { id: "todo-002", title: "Second", _etag: "etag-2", _ts: 2 },
+          { id: "todo-001", title: "First", _rid: "rid-1", _self: "self-1" },
+        ],
+        "todo.json"
+      )
+    ).toEqual([
+      { id: "todo-001", title: "First" },
+      { id: "todo-002", title: "Second" },
+    ]);
+  });
+
   it("builds nested template documents from related schemas", () => {
     const category = createBasicModelInfo({
       name: "Category",

package/src/__tests__/dev.test.ts

@@ -1,16 +1,65 @@
+import * as http from "http";
+import { readFileSync } from "fs";
 import * as path from "path";
 import {
+  buildFunctionsBaseUrl,
   buildFunctionsStartArgs,
+  buildFunctionsCoreToolsCommand,
   buildNextDevArgs,
+  buildSwaStartArgs,
+  buildDevCommand,
+  buildFunctionsCosmosEnvironment,
   buildPythonFunctionsEnv,
+  compareVersionNumbers,
+  DevOptions,
+  getFunctionsReadinessTimeoutMs,
+  getCSharpFunctionsBuildArtifactPaths,
   getPythonVirtualEnvPaths,
+  getSwaCliInstallCommand,
+  parseCoreToolsVersion,
+  waitForHttpServerReady,
 } from "../cli/commands/dev";
+import { CLI_VERSION, createProgram, normalizeDevCommandArgv } from "../cli/index";
+
+const packageVersion = JSON.parse(
+  readFileSync(path.resolve(__dirname, "../../package.json"), "utf8")
+).version as string;
 
 describe("dev command helpers", () => {
+  it("keeps the CLI version in sync with package.json", () => {
+    expect(CLI_VERSION).toBe(packageVersion);
+  });
+
   it("passes the requested port to Azure Functions Core Tools", () => {
     expect(buildFunctionsStartArgs("7076")).toEqual(["start", "--port", "7076"]);
   });
 
+  it("parses the Core Tools version from CLI output", () => {
+    expect(parseCoreToolsVersion("4.6.0+ab90faafcab539d63cd3d0ce5faf1bca4395fccc")).toBe("4.6.0");
+  });
+
+  it("compares Core Tools versions numerically", () => {
+    expect(compareVersionNumbers("4.0.5198", "4.6.0")).toBeLessThan(0);
+    expect(compareVersionNumbers("4.6.0", "4.6.0")).toBe(0);
+    expect(compareVersionNumbers("4.10.0", "4.6.0")).toBeGreaterThan(0);
+  });
+
+  it("falls back to npm Core Tools for older C# isolated hosts", () => {
+    expect(buildFunctionsCoreToolsCommand("csharp", "4.0.5198")).toEqual({
+      command: "npm",
+      argsPrefix: ["exec", "--yes", "azure-functions-core-tools@4", "--"],
+      label: "npm exec azure-functions-core-tools@4 (installed func 4.0.5198 is too old for C# isolated)",
+    });
+  });
+
+  it("keeps the installed func command for supported Core Tools versions", () => {
+    expect(buildFunctionsCoreToolsCommand("csharp", "4.6.0")).toEqual({
+      command: "func",
+      argsPrefix: [],
+      label: "func 4.6.0",
+    });
+  });
+
   it("uses webpack mode for npm-based Next.js dev", () => {
     expect(buildNextDevArgs("npm", "3012")).toEqual(["next", "dev", "--port", "3012", "--webpack"]);
   });
@@ -19,6 +68,65 @@ describe("dev command helpers", () => {
     expect(buildNextDevArgs("pnpm", "3012")).toEqual(["exec", "next", "dev", "--port", "3012", "--webpack"]);
   });
 
+  it("builds the Azure Functions base URL from host and port", () => {
+    expect(buildFunctionsBaseUrl(undefined, "7071")).toBe("http://localhost:7071");
+    expect(buildFunctionsBaseUrl("127.0.0.1", "7072")).toBe("http://127.0.0.1:7072");
+  });
+
+  it("builds SWA CLI arguments without bypassing the Next.js BFF", () => {
+    expect(buildSwaStartArgs(undefined, "3000", "4280")).toEqual([
+      "start",
+      "http://localhost:3000",
+      "--swa-config-location",
+      ".",
+      "--port",
+      "4280",
+    ]);
+    expect(buildSwaStartArgs(undefined, "3000", "4280")).not.toContain("--api-devserver-url");
+  });
+
+  it("provides a project-local SWA CLI install command", () => {
+    expect(getSwaCliInstallCommand("pnpm")).toBe("pnpm add -Dw @azure/static-web-apps-cli");
+    expect(getSwaCliInstallCommand("npm")).toBe("npm install -D @azure/static-web-apps-cli");
+  });
+
+  it("gives C# more startup time before reporting readiness timeout", () => {
+    expect(getFunctionsReadinessTimeoutMs("csharp")).toBeGreaterThan(getFunctionsReadinessTimeoutMs("typescript"));
+    expect(getFunctionsReadinessTimeoutMs("csharp")).toBeGreaterThan(getFunctionsReadinessTimeoutMs("python"));
+  });
+
+  it("waits until an HTTP server responds before reporting ready", async () => {
+    const server = http.createServer((_request, response) => {
+      response.writeHead(404);
+      response.end("not found");
+    });
+
+    await new Promise<void>((resolve) => {
+      server.listen(0, "127.0.0.1", () => resolve());
+    });
+
+    const address = server.address();
+    if (!address || typeof address === "string") {
+      throw new Error("Failed to determine ephemeral port.");
+    }
+
+    try {
+      await expect(
+        waitForHttpServerReady(`http://127.0.0.1:${address.port}`, 2_000, 50)
+      ).resolves.toBe(true);
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  });
+
   it("builds Python virtual environment paths under functions/.venv", () => {
     const functionsDir = path.join("C:\\repo", "functions");
     const paths = getPythonVirtualEnvPaths(functionsDir);
@@ -28,6 +136,15 @@ describe("dev command helpers", () => {
     expect(paths.pythonExecutable.endsWith(process.platform === "win32" ? path.join("Scripts", "python.exe") : path.join("bin", "python"))).toBe(true);
   });
 
+  it("targets C# bin and obj directories for build cleanup", () => {
+    const functionsDir = path.join("C:\\repo", "functions");
+
+    expect(getCSharpFunctionsBuildArtifactPaths(functionsDir)).toEqual([
+      path.join(functionsDir, "bin"),
+      path.join(functionsDir, "obj"),
+    ]);
+  });
+
   it("injects Python virtual environment settings for Functions", () => {
     const functionsDir = path.join("C:\\repo", "functions");
     const env = buildPythonFunctionsEnv({ PATH: "C:\\Windows\\System32" }, functionsDir);
@@ -39,4 +156,141 @@ describe("dev command helpers", () => {
     );
     expect(env.PATH?.startsWith(`${expectedBinDir}${path.delimiter}`)).toBe(true);
   });
+
+  it("passes the resolved Cosmos database name to Azure Functions", () => {
+    const baseEnv = { PATH: "test-path", COSMOS_DB_DATABASE_NAME: "BaseDatabase" };
+    const env = buildFunctionsCosmosEnvironment(baseEnv, "BaseDatabase_a31f92c4");
+
+    expect(env.COSMOS_DB_DATABASE_NAME).toBe("BaseDatabase_a31f92c4");
+    expect(baseEnv.COSMOS_DB_DATABASE_NAME).toBe("BaseDatabase");
+  });
+});
+
+describe("dev CLI parser", () => {
+  it("exposes the Static Web Apps plan option on init", () => {
+    const init = createProgram().commands.find((command) => command.name() === "init");
+    const option = init?.options.find((candidate) => candidate.long === "--swa-plan");
+
+    expect(option).toBeDefined();
+    expect(option?.description).toContain("free | standard");
+  });
+
+  async function parseDevOptions(argv: string[]): Promise<DevOptions> {
+    let capturedOptions: DevOptions | undefined;
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+    const program = createProgram(buildDevCommand(async (options) => {
+      capturedOptions = options;
+    }, () => undefined));
+
+    program.exitOverride();
+
+    try {
+      await program.parseAsync(normalizeDevCommandArgv(argv));
+    } finally {
+      logSpy.mockRestore();
+    }
+
+    expect(capturedOptions).toBeDefined();
+    return capturedOptions!;
+  }
+
+  it("normalizes dev options placed before the subcommand", () => {
+    expect(
+      normalizeDevCommandArgv([
+        "node",
+        "swallowkit",
+        "--seed-env",
+        "local",
+        "--mock-connectors",
+        "dev",
+        "--port",
+        "3001",
+      ])
+    ).toEqual([
+      "node",
+      "swallowkit",
+      "dev",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+      "--port",
+      "3001",
+    ]);
+  });
+
+  it("keeps non-dev commands unchanged", () => {
+    const argv = ["node", "swallowkit", "create-model", "dev", "--connector", "external"];
+    expect(normalizeDevCommandArgv(argv)).toEqual(argv);
+  });
+
+  it("parses the same dev options regardless of whether they appear before or after the subcommand", async () => {
+    const expected = {
+      port: "3001",
+      functionsPort: "7072",
+      host: "127.0.0.1",
+      open: true,
+      verbose: true,
+      noFunctions: true,
+      seedEnv: "local",
+      mockConnectors: true,
+      swaPort: "4290",
+      noSwa: true,
+    };
+
+    const optionsAfterCommand = await parseDevOptions([
+      "node",
+      "swallowkit",
+      "dev",
+      "--port",
+      "3001",
+      "--functions-port",
+      "7072",
+      "--host",
+      "127.0.0.1",
+      "--open",
+      "--verbose",
+      "--no-functions",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+      "--swa-port",
+      "4290",
+      "--no-swa",
+    ]);
+
+    const optionsBeforeCommand = await parseDevOptions([
+      "node",
+      "swallowkit",
+      "--verbose",
+      "--host",
+      "127.0.0.1",
+      "--seed-env",
+      "local",
+      "--mock-connectors",
+      "--swa-port",
+      "4290",
+      "--no-swa",
+      "--no-functions",
+      "--port",
+      "3001",
+      "--functions-port",
+      "7072",
+      "--open",
+      "dev",
+    ]);
+
+    expect(optionsAfterCommand).toMatchObject(expected);
+    expect(optionsBeforeCommand).toMatchObject(expected);
+    expect({ ...optionsBeforeCommand }).toMatchObject({ ...optionsAfterCommand });
+  });
+
+  it("keeps Azure Functions enabled by default", async () => {
+    const options = await parseDevOptions([
+      "node",
+      "swallowkit",
+      "dev",
+    ]);
+
+    expect(options.noFunctions).toBe(false);
+  });
 });

package/src/__tests__/file-session.test.ts

@@ -0,0 +1,98 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  FileOperationSession,
+  hashContent,
+  runWithFileSession,
+  getActiveFileSession,
+} from "../core/operations/file-session";
+
+describe("FileOperationSession", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-session-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("writes files to disk in commit mode and records create operations", () => {
+    const session = new FileOperationSession("commit", tempDir);
+    const target = path.join(tempDir, "nested", "dir", "file.ts");
+
+    const op = session.writeFile(target, "export const a = 1;\n", {
+      ownership: "managed",
+      generator: "scaffold",
+      sourceModel: "Todo",
+    });
+
+    expect(fs.readFileSync(target, "utf-8")).toBe("export const a = 1;\n");
+    expect(op.action).toBe("create");
+    expect(op.path).toBe("nested/dir/file.ts");
+    expect(op.previousHash).toBeNull();
+    expect(op.newHash).toBe(hashContent("export const a = 1;\n"));
+  });
+
+  it("does not touch the disk in collect mode", () => {
+    const session = new FileOperationSession("collect", tempDir);
+    const target = path.join(tempDir, "virtual.ts");
+
+    session.writeFile(target, "content", { ownership: "managed", generator: "scaffold" });
+
+    expect(fs.existsSync(target)).toBe(false);
+    expect(session.operations).toHaveLength(1);
+    expect(session.operations[0].action).toBe("create");
+    // overlay read-back
+    expect(session.readFile(target)).toBe("content");
+    expect(session.fileExists(target)).toBe(true);
+  });
+
+  it("records skip when content is unchanged", () => {
+    const target = path.join(tempDir, "same.ts");
+    fs.writeFileSync(target, "unchanged\n", "utf-8");
+
+    const session = new FileOperationSession("commit", tempDir);
+    const op = session.writeFile(target, "unchanged\n", { ownership: "managed", generator: "scaffold" });
+
+    expect(op.action).toBe("skip");
+  });
+
+  it("records append for extension-point modifications and modify for managed", () => {
+    const extensionTarget = path.join(tempDir, "ext.ts");
+    const managedTarget = path.join(tempDir, "managed.ts");
+    fs.writeFileSync(extensionTarget, "base\n", "utf-8");
+    fs.writeFileSync(managedTarget, "base\n", "utf-8");
+
+    const session = new FileOperationSession("commit", tempDir);
+    const appendOp = session.writeFile(extensionTarget, "base\nmore\n", {
+      ownership: "extension-point",
+      generator: "scaffold",
+    });
+    const modifyOp = session.writeFile(managedTarget, "regenerated\n", {
+      ownership: "managed",
+      generator: "scaffold",
+    });
+
+    expect(appendOp.action).toBe("append");
+    expect(modifyOp.action).toBe("modify");
+    expect(modifyOp.previousHash).toBe(hashContent("base\n"));
+  });
+
+  it("normalizes CRLF for hashing", () => {
+    expect(hashContent("a\r\nb\r\n")).toBe(hashContent("a\nb\n"));
+  });
+
+  it("scopes the active session with runWithFileSession", async () => {
+    expect(getActiveFileSession()).toBeNull();
+    const session = new FileOperationSession("collect", tempDir);
+
+    await runWithFileSession(session, async () => {
+      expect(getActiveFileSession()).toBe(session);
+    });
+
+    expect(getActiveFileSession()).toBeNull();
+  });
+});