@pmelab/gtd 62.1.0 → 64.0.0

package/src/platform/NodeSync.ts

@@ -0,0 +1,64 @@
+import { execFileSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import {
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+  type Stats,
+} from "node:fs"
+import type { FileInfo, SyncIo } from "./SyncIo.js"
+
+// A tree listing, or one committed file, can overflow execFileSync's 1 MB default.
+const MAX_BUFFER = 256 * 1024 * 1024
+
+const isAbsent = (e: unknown): boolean => {
+  const code = (e as NodeJS.ErrnoException).code
+  return code === "ENOENT" || code === "ENOTDIR"
+}
+
+const orAbsent = <A>(read: () => A): A | undefined => {
+  try {
+    return read()
+  } catch (e) {
+    if (isAbsent(e)) return undefined
+    throw e
+  }
+}
+
+const infoOf = (stats: Stats): FileInfo => ({
+  type: stats.isSymbolicLink()
+    ? "symlink"
+    : stats.isDirectory()
+      ? "directory"
+      : stats.isFile()
+        ? "file"
+        : "other",
+  uid: process.platform === "win32" ? undefined : stats.uid,
+})
+
+export const nodeSyncIo: SyncIo = {
+  readFile: (path) => orAbsent(() => readFileSync(path)),
+  readText: (path) => orAbsent(() => readFileSync(path, "utf8")),
+  writeText: (path, content) => writeFileSync(path, content, "utf8"),
+  makeDirectory: (path) => {
+    mkdirSync(path, { recursive: true })
+  },
+  rename: renameSync,
+  stat: (path) => orAbsent(() => infoOf(statSync(path))),
+  lstat: (path) => orAbsent(() => infoOf(lstatSync(path))),
+  readLink: (path) => readlinkSync(path, "utf8"),
+  realPath: (path) => realpathSync(path),
+  git: (cwd, args) => execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: MAX_BUFFER }),
+  gitBytes: (cwd, args) =>
+    execFileSync("git", args, { cwd, maxBuffer: MAX_BUFFER, stdio: ["ignore", "pipe", "ignore"] }),
+  hash: (algorithm, ...parts) => {
+    const hash = createHash(algorithm)
+    for (const part of parts) hash.update(part)
+    return hash.digest("hex")
+  },
+}

package/src/platform/PinFile.ts

@@ -1,9 +1,3 @@
-import { execFileSync } from "node:child_process"
-import { existsSync, readFileSync } from "node:fs"
-import { registerHooks } from "node:module"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-
 /** A process's pin as the launcher found it: the file's bytes and where its engine runs from. */
 export interface FoundPin {
   readonly path: string
@@ -15,47 +9,3 @@ export interface FoundPin {
  * the landing after an unpin beat deleted the file still runs on the pin.
  */
 export type PinFile = () => FoundPin | undefined
-
-// `cwd`, as the engine's own root is: gtd runs only at the worktree root, and
-// a relocated `$GIT_DIR` leaves no `.git` to walk up to. A file that cannot be
-// read counts as no pin, so the launcher refuses it rather than crashing.
-export const livePinFile =
-  (cwd: string, path: string): PinFile =>
-  () => {
-    const file = join(cwd, path)
-    if (existsSync(file)) {
-      try {
-        return { path: file, bytes: readFileSync(file) }
-      } catch {
-        return { path: file, bytes: new Uint8Array() }
-      }
-    }
-    try {
-      const bytes = execFileSync("git", ["show", `HEAD:${path}`], {
-        cwd,
-        stdio: ["ignore", "pipe", "ignore"],
-      })
-      return { path: file, bytes }
-    } catch {
-      return undefined
-    }
-  }
-
-/**
- * Runs a pin's module as this process's main program. Node refuses an unknown
- * extension, so a load hook serves the unpacked source under the pin's own
- * URL — `import.meta.url` stays a file in the repository.
- */
-export const runPinModule = async (path: string, source: string): Promise<void> => {
-  const url = pathToFileURL(path).href
-  // A pin read from HEAD has no file behind its URL, which Node's own resolve refuses.
-  registerHooks({
-    resolve: (specifier, context, nextResolve) =>
-      specifier === url ? { url, shortCircuit: true } : nextResolve(specifier, context),
-    load: (requested, context, nextLoad) =>
-      requested === url
-        ? { format: "module", source, shortCircuit: true }
-        : nextLoad(requested, context),
-  })
-  await import(url)
-}

package/src/platform/Sha.ts

@@ -0,0 +1,121 @@
+import type { HashAlgorithm } from "./SyncIo.js"
+
+// The digest for a runtime without Node's crypto, which the in-memory tier runs on.
+
+const K256 = Uint32Array.from([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+])
+
+const rotl = (x: number, n: number): number => (x << n) | (x >>> (32 - n))
+const rotr = (x: number, n: number): number => (x >>> n) | (x << (32 - n))
+
+/** `data` padded to whole 64-byte blocks, its bit length big-endian at the end. */
+const padded = (data: Uint8Array): DataView => {
+  const length = Math.ceil((data.length + 9) / 64) * 64
+  const bytes = new Uint8Array(length)
+  bytes.set(data)
+  bytes[data.length] = 0x80
+  const view = new DataView(bytes.buffer)
+  view.setUint32(length - 8, Math.floor(data.length / 0x20000000))
+  view.setUint32(length - 4, (data.length * 8) >>> 0)
+  return view
+}
+
+/** Round `i`'s boolean function of `b`, `c`, `d`, plus its constant. */
+const sha1Mix = (i: number, b: number, c: number, d: number): number =>
+  i < 20
+    ? ((b & c) | (~b & d)) + 0x5a827999
+    : i < 40
+      ? (b ^ c ^ d) + 0x6ed9eba1
+      : i < 60
+        ? ((b & c) | (b & d) | (c & d)) + 0x8f1bbcdc
+        : (b ^ c ^ d) + 0xca62c1d6
+
+const sha1 = (view: DataView): Uint32Array => {
+  const h = Uint32Array.from([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0])
+  const w = new Uint32Array(80)
+  for (let block = 0; block < view.byteLength; block += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(block + i * 4)
+    for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3]! ^ w[i - 8]! ^ w[i - 14]! ^ w[i - 16]!, 1)
+    let [a, b, c, d, e] = [h[0]!, h[1]!, h[2]!, h[3]!, h[4]!]
+    for (let i = 0; i < 80; i++) {
+      const t = (rotl(a, 5) + sha1Mix(i, b, c, d) + e + w[i]!) | 0
+      e = d
+      d = c
+      c = rotl(b, 30)
+      b = a
+      a = t
+    }
+    h[0]! += a
+    h[1]! += b
+    h[2]! += c
+    h[3]! += d
+    h[4]! += e
+  }
+  return h
+}
+
+const sha256 = (view: DataView): Uint32Array => {
+  const h = Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ])
+  const w = new Uint32Array(64)
+  for (let block = 0; block < view.byteLength; block += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(block + i * 4)
+    for (let i = 16; i < 64; i++) {
+      const x = w[i - 15]!
+      const y = w[i - 2]!
+      const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3)
+      const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10)
+      w[i] = w[i - 16]! + s0 + w[i - 7]! + s1
+    }
+    let [a, b, c, d, e, f, g, hh] = [h[0]!, h[1]!, h[2]!, h[3]!, h[4]!, h[5]!, h[6]!, h[7]!]
+    for (let i = 0; i < 64; i++) {
+      const t1 =
+        (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K256[i]! + w[i]!) |
+        0
+      const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0
+      hh = g
+      g = f
+      f = e
+      e = (d + t1) | 0
+      d = c
+      c = b
+      b = a
+      a = (t1 + t2) | 0
+    }
+    h[0]! += a
+    h[1]! += b
+    h[2]! += c
+    h[3]! += d
+    h[4]! += e
+    h[5]! += f
+    h[6]! += g
+    h[7]! += hh
+  }
+  return h
+}
+
+const encoder = new TextEncoder()
+
+export const pureHash = (
+  algorithm: HashAlgorithm,
+  ...parts: readonly (string | Uint8Array)[]
+): string => {
+  const chunks = parts.map((part) => (typeof part === "string" ? encoder.encode(part) : part))
+  const data = new Uint8Array(chunks.reduce((n, chunk) => n + chunk.length, 0))
+  let at = 0
+  for (const chunk of chunks) {
+    data.set(chunk, at)
+    at += chunk.length
+  }
+  const words = (algorithm === "sha1" ? sha1 : sha256)(padded(data))
+  return [...words].map((word) => word.toString(16).padStart(8, "0")).join("")
+}

package/src/platform/SyncIo.ts

@@ -0,0 +1,35 @@
+export type HashAlgorithm = "sha1" | "sha256"
+
+export interface FileInfo {
+  readonly type: "file" | "directory" | "symlink" | "other"
+  /** `undefined` where the platform has no POSIX user ids. */
+  readonly uid: number | undefined
+}
+
+/**
+ * The machine reads that must stay synchronous: workflows read the tree
+ * between two awaits during replay, so neither the reads nor the hashing
+ * behind them can wait on IO. Absence is a value (`undefined`); any other
+ * fault throws.
+ */
+export interface SyncIo {
+  readonly readFile: (path: string) => Uint8Array | undefined
+  readonly readText: (path: string) => string | undefined
+  readonly writeText: (path: string, content: string) => void
+  /** Creates every missing parent too. */
+  readonly makeDirectory: (path: string) => void
+  readonly rename: (from: string, to: string) => void
+  /** Follows a symlink. */
+  readonly stat: (path: string) => FileInfo | undefined
+  /** Reports a symlink as one. */
+  readonly lstat: (path: string) => FileInfo | undefined
+  readonly readLink: (path: string) => string
+  /** Throws when `path` does not exist. */
+  readonly realPath: (path: string) => string
+  /** git's stdout; throws on a non-zero exit, with git's stderr passed through. */
+  readonly git: (cwd: string, args: readonly string[]) => string
+  /** `git`'s raw stdout, with its stderr discarded. */
+  readonly gitBytes: (cwd: string, args: readonly string[]) => Uint8Array
+  /** Lowercase hex digest of the parts, concatenated; a string part is UTF-8. */
+  readonly hash: (algorithm: HashAlgorithm, ...parts: readonly (string | Uint8Array)[]) => string
+}

package/src/platform/Workspace.test.ts

@@ -54,7 +54,9 @@ const makeLiveTier = (): WorkspaceTier => {
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
   const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
-  const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+  const workspaceLayer = Workspace.Live.pipe(
+    Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+  )
 
   return {
     root,
@@ -270,8 +272,9 @@ describe("Workspace [Live] worktreeSync", () => {
         Effect.provide(
           Workspace.Live.pipe(
             Layer.provide(
-              Layer.merge(
+              Layer.mergeAll(
                 Host.layer({ root, home: root, env: {} }),
+                NodeServices.layer,
                 GitService.Live.pipe(
                   Layer.provide(
                     Layer.merge(Host.layer({ root, home: root, env: {} }), NodeServices.layer),
@@ -361,7 +364,9 @@ const makeLiveEpisodeTier = () => {
 
   const hostLayer = Host.layer({ root, home: root, env: {} })
   const gitLayer = GitService.Live.pipe(Layer.provide(Layer.merge(hostLayer, NodeServices.layer)))
-  const workspaceLayer = Workspace.Live.pipe(Layer.provide(Layer.merge(hostLayer, gitLayer)))
+  const workspaceLayer = Workspace.Live.pipe(
+    Layer.provide(Layer.mergeAll(hostLayer, gitLayer, NodeServices.layer)),
+  )
   const ops = (): Promise<WorkspaceOps> =>
     Effect.runPromise(
       Effect.gen(function* () {