@akanjs/devkit 3.0.0-beta.18 → 3.0.0-beta.19

package/platformTest/WindowsSshTarget.ts

@@ -0,0 +1,167 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { PlatformGatePolicy, WindowsTestTargetConfig } from "../cloud/constants";
+import { IdleWatchedProcess } from "./IdleWatchedProcess";
+import { type PlatformRunContext, PlatformTestTarget } from "./PlatformTestTarget";
+
+export class WindowsSshTarget extends PlatformTestTarget {
+  static readonly utmctlPath = "/Applications/UTM.app/Contents/MacOS/utmctl";
+  static readonly defaultWorkRoot = "C:\\akan-test";
+  //* arm64 has neither a sharp@0.32 prebuilt nor a Chrome for puppeteer's postinstall; x64 users get both.
+  static readonly defaultTolerateScriptFailures = ["sharp", "puppeteer"];
+  static readonly #runDirPattern = "^\\d{8}-\\d{6}$";
+  static readonly #keptRuns = 2;
+
+  readonly platform = "windows";
+  readonly policy: PlatformGatePolicy;
+  protected override readonly tolerateScriptFailures: string[];
+  readonly #config: WindowsTestTargetConfig;
+  #host: string;
+  #runDir: string | null = null;
+
+  constructor(config: WindowsTestTargetConfig) {
+    super();
+    this.#config = config;
+    this.#host = process.env.AKAN_TEST_WINDOWS_HOST ?? config.host;
+    this.policy = config.policy ?? "warn";
+    this.tolerateScriptFailures = config.tolerateScriptFailures ?? WindowsSshTarget.defaultTolerateScriptFailures;
+  }
+
+  get #workRoot() {
+    return this.#config.workRoot ?? WindowsSshTarget.defaultWorkRoot;
+  }
+
+  protected async prepare(context: PlatformRunContext) {
+    await this.#connect();
+    const bunVersion = (await this.#ssh("bun --version")).stdout.trim();
+    if (bunVersion !== Bun.version)
+      throw new Error(
+        `the Windows host runs Bun ${bunVersion || "(none)"}, this host ${Bun.version} — align them first`,
+      );
+    if ((await this.#ssh("git --version")).exitCode !== 0) throw new Error("git is not installed on the Windows host");
+    const runDir = `${this.#workRoot}\\${context.runId}`;
+    const mkdir = await this.#ssh(`New-Item -ItemType Directory -Force -Path '${runDir}\\w' | Out-Null`);
+    if (mkdir.exitCode !== 0) throw new Error(`could not create ${runDir}: ${mkdir.stderr.trim()}`);
+    this.#runDir = runDir;
+    for (const [local, remoteName] of [
+      [context.snapshot.tarPath, "src.tar"],
+      [context.envPath, "env"],
+    ] as const) {
+      const copied = await WindowsSshTarget.#run([
+        ...this.#scpBase(),
+        local,
+        this.#remoteScpPath(`${runDir}\\${remoteName}`),
+      ]);
+      if (copied.exitCode !== 0) throw new Error(`scp ${remoteName} failed: ${copied.stderr.trim()}`);
+    }
+    const extract = await this.exec(
+      "tar -xf ..\\src.tar && copy /Y ..\\env .env >nul && git init -q",
+      path.join(context.logDir, this.platform, "extract.log"),
+      PlatformTestTarget.installIdleMs,
+    );
+    if (extract.exitCode !== 0) throw new Error("extracting the snapshot on the Windows host failed");
+  }
+
+  protected async exec(command: string, logPath: string, idleMs: number) {
+    const runDir = this.#runDir;
+    if (!runDir) throw new Error("the Windows run directory was not prepared");
+    let remotePid: string | null = null;
+    const script = [
+      "$ProgressPreference = 'SilentlyContinue'",
+      "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+      "'PID=' + $PID",
+      "$env:GIT_AUTHOR_NAME = 'akan-test'",
+      "$env:GIT_AUTHOR_EMAIL = 'akan-test@localhost'",
+      "$env:GIT_COMMITTER_NAME = 'akan-test'",
+      "$env:GIT_COMMITTER_EMAIL = 'akan-test@localhost'",
+      "$env:GIT_CONFIG_COUNT = '1'",
+      "$env:GIT_CONFIG_KEY_0 = 'init.defaultBranch'",
+      "$env:GIT_CONFIG_VALUE_0 = 'main'",
+      `Set-Location -LiteralPath '${runDir}\\w'`,
+      `cmd /c "${command} 2>&1"`,
+      "exit $LASTEXITCODE",
+    ].join("; ");
+    return await new IdleWatchedProcess([...this.#sshBase(), script], {
+      logPath,
+      idleMs,
+      onOutput: (text) => {
+        remotePid ??= /PID=(\d+)/.exec(text)?.[1] ?? null;
+      },
+      onIdle: async () => {
+        if (remotePid) await this.#ssh(`taskkill /F /T /PID ${remotePid} | Out-Null`);
+      },
+    }).run();
+  }
+
+  protected async cleanup() {
+    this.#runDir = null;
+    await this.#ssh(
+      [
+        `Get-ChildItem -LiteralPath '${this.#workRoot}' -Directory`,
+        `Where-Object { $_.Name -match '${WindowsSshTarget.#runDirPattern}' }`,
+        "Sort-Object Name -Descending",
+        `Select-Object -Skip ${WindowsSshTarget.#keptRuns}`,
+        "ForEach-Object { cmd /c rmdir /s /q $_.FullName }",
+      ].join(" | "),
+    );
+  }
+
+  async #connect() {
+    if ((await this.#ssh("exit 0")).exitCode === 0) return;
+    const vm = this.#config.utmVm;
+    if (!vm || !existsSync(WindowsSshTarget.utmctlPath))
+      throw new Error(`cannot reach ${this.#config.user}@${this.#host} over ssh`);
+    const status = (await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "status", vm])).stdout.trim();
+    if (status !== "started") await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "start", vm]);
+    for (let attempt = 0; attempt < 24; attempt++) {
+      const addresses = (await WindowsSshTarget.#run([WindowsSshTarget.utmctlPath, "ip-address", vm])).stdout;
+      const ipv4 = addresses.split(/\s+/).find((address) => /^\d+\.\d+\.\d+\.\d+$/.test(address));
+      if (ipv4) this.#host = ipv4;
+      if ((await this.#ssh("exit 0")).exitCode === 0) return;
+      await Bun.sleep(5_000);
+    }
+    throw new Error(`UTM VM "${vm}" did not answer ssh at ${this.#host}`);
+  }
+
+  #sshOptions() {
+    const expand = (file: string) => (file.startsWith("~/") ? path.join(os.homedir(), file.slice(2)) : file);
+    return [
+      "-i",
+      expand(this.#config.identityFile),
+      ...(this.#config.knownHostsFile ? ["-o", `UserKnownHostsFile=${expand(this.#config.knownHostsFile)}`] : []),
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=8",
+      "-o",
+      "ServerAliveInterval=30",
+    ];
+  }
+
+  #sshBase() {
+    return ["ssh", ...this.#sshOptions(), `${this.#config.user}@${this.#host}`];
+  }
+
+  #scpBase() {
+    return ["scp", "-q", ...this.#sshOptions()];
+  }
+
+  #remoteScpPath(windowsPath: string) {
+    return `${this.#config.user}@${this.#host}:/${windowsPath.replaceAll("\\", "/")}`;
+  }
+
+  async #ssh(script: string) {
+    return await WindowsSshTarget.#run([...this.#sshBase(), script]);
+  }
+
+  static async #run(command: string[]) {
+    const proc = Bun.spawn(command, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { stdout, stderr, exitCode };
+  }
+}

package/subspace.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, setDefaultTimeout, test } from "bun:test";
 import { mkdir, mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -7,6 +7,9 @@ import { FileSys } from "./fileSys";
 import { formatSubspaceDiff, formatSubspacePushResults, formatSubspaceStatuses, Subspace } from "./subspace";
 import { SubspaceConfig } from "./subspaceConfig";
 
+//? Each case drives several real git clones and pushes; on a 4-core Windows VM that alone lands at 2-5s.
+setDefaultTimeout(20_000);
+
 const tempRoots: string[] = [];
 const originalEnv = { ...process.env };
 
@@ -96,7 +99,7 @@ const makeMirror = async (servedApp: string, privateApp: string, libName: string
   await write(path.join(wsRoot, "benchmarks/bench.ts"), "export {};\n");
   await write(
     path.join(wsRoot, "akan.subspace.ts"),
-    `export default { pushableBranches: ["develop"], exclude: ["benchmarks"], subspaces: [{ name: "acme", repo: "${bareRoot}", apps: ["${servedApp}"] }] };\n`,
+    `export default { pushableBranches: ["develop"], exclude: ["benchmarks"], subspaces: [{ name: "acme", repo: ${JSON.stringify(bareRoot)}, apps: ["${servedApp}"] }] };\n`,
   );
 
   await makeSys(wsRoot, "apps", servedApp, {

package/subspace.ts

@@ -296,15 +296,25 @@ export class Subspace {
   /**
    * `git archive` emits exactly the tracked files at HEAD, which is why the copy needs no exclude list of
    * its own: generated barrels, the `(libs)`/`public/libs` symlinks, env values, secrets and the lockfile
-   * are all outside git and cannot enter the archive. Directory arguments only — a file list would put
-   * route paths like `page/(docs)/…` through a shell.
+   * are all outside git and cannot enter the archive. Spawned without a shell, whose quoting differs between
+   * `sh` and `cmd.exe`.
    */
   async #extract(paths: string[], excludes: string[] = []) {
-    const pathspec = paths.map((entry) => `'${entry}'`).join(" ");
-    const excludeArgs = excludes.map((entry) => `--exclude='${entry}'`).join(" ");
-    await this.#workspace.exec(
-      `git archive HEAD -- ${pathspec} | tar -x -C '${this.#clonePath}' ${excludeArgs}`.trim(),
-    );
+    // Relative, because GNU tar reads a drive-letter archive name (`C:\…`) as `host:path` on a remote host.
+    const archivePath = path.relative(this.#workspace.workspaceRoot, `${this.#clonePath}.tar`);
+    await this.#workspace.spawn("git", ["archive", "-o", archivePath, "HEAD", "--", ...paths]);
+    try {
+      await this.#workspace.spawn("tar", [
+        "-x",
+        "-f",
+        archivePath,
+        "-C",
+        this.#clonePath,
+        ...excludes.map((entry) => `--exclude=${entry}`),
+      ]);
+    } finally {
+      await rm(path.join(this.#workspace.workspaceRoot, archivePath), { force: true });
+    }
   }
 
   /**
@@ -399,7 +409,8 @@ export class Subspace {
     const gitignorePath = path.join(this.#clonePath, ".gitignore");
     if (!(await FileSys.fileExists(gitignorePath))) return;
     const [begin = "", end = ""] = Subspace.secretsMarkers;
-    const lines = (await FileSys.readText(gitignorePath)).split("\n");
+    // `git archive` checks text out as CRLF under Windows Git's default `core.autocrlf=true`.
+    const lines = (await FileSys.readText(gitignorePath)).split(/\r?\n/);
     const beginIdx = lines.indexOf(begin);
     const endIdx = lines.indexOf(end);
     const filtered =

package/workflow/rolloutGate.test.ts

@@ -24,7 +24,7 @@ const workspacePackageManifestPaths = async () => {
   for (const workspace of workspaces) {
     const glob = new Bun.Glob(`${workspace}/package.json`);
     for await (const relativePath of glob.scan({ cwd: workspaceRoot, onlyFiles: true })) {
-      paths.add(relativePath);
+      paths.add(relativePath.split(path.sep).join("/"));
     }
   }
   return [...paths].sort();