@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/runtime/workspace/artifacts.mjs

@@ -0,0 +1,121 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { constants } from "node:fs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { RuntimeId, canonicalJson } from "@ricsam/r5d-api/runtime-protocol";
+import { noSymlinkAncestors, durableJson, readRegular } from "./files.mjs";
+import { WorkspaceError } from "./contracts.mjs";
+const SessionArtifactChunk = z.object({
+  method: z.literal("materializeArtifact"),
+  id: RuntimeId,
+  filename: z.string().min(1).max(200).refine((name) => name !== "." && name !== ".." && !/[\\/\0]/.test(name)),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/),
+  size: z.number().int().min(0).max(100 * 1024 * 1024),
+  offset: z.number().int().min(0).max(100 * 1024 * 1024),
+  base64: z.string().max(88e3),
+  seal: z.boolean()
+}).strict();
+const RESERVED_ARTIFACT_ENV = ["R5D_ROOT", "R5D_SESSION_ID"];
+const sha = (value) => createHash("sha256").update(value).digest("hex");
+class SessionArtifactStore {
+  constructor(authorityRoot) {
+    this.authorityRoot = authorityRoot;
+  }
+  authorityRoot;
+  async environment(identity) {
+    const scope = { userId: RuntimeId.parse(identity.userId), sessionId: RuntimeId.parse(identity.sessionId) };
+    const base = path.join(this.authorityRoot, "session-artifacts"), root = path.join(base, sha(canonicalJson(scope)));
+    for (const directory of [
+      base,
+      root,
+      path.join(root, "artifacts"),
+      path.join(root, "artifacts", identity.sessionId),
+      path.join(root, ".incoming")
+    ]) {
+      await fs.mkdir(directory, { mode: 448 }).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      await noSymlinkAncestors(directory);
+    }
+    return { R5D_ROOT: root, R5D_SESSION_ID: identity.sessionId };
+  }
+  async materialize(identity, input) {
+    const chunk = SessionArtifactChunk.parse(input), bytes = Buffer.from(chunk.base64, "base64");
+    if (bytes.length > 64 * 1024 || bytes.toString("base64") !== chunk.base64 || chunk.offset + bytes.length > chunk.size)
+      throw new WorkspaceError("invalid_artifact_chunk", "Invalid bounded artifact bytes");
+    const env = await this.environment(identity), destination = path.join(env.R5D_ROOT, "artifacts", identity.sessionId, chunk.filename), incoming = path.join(env.R5D_ROOT, ".incoming", sha(chunk.filename));
+    const binding = { filename: chunk.filename, sha256: chunk.sha256, size: chunk.size }, manifest = `${incoming}.json`, temporary = `${incoming}.part`;
+    const old = await readRegular(manifest, 1024).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (old && canonicalJson(JSON.parse(old.toString())) !== canonicalJson(binding))
+      throw new WorkspaceError("artifact_payload_mismatch", "Artifact name is already bound to different bytes");
+    if (!old) await durableJson(manifest, binding);
+    const completed = await fs.lstat(destination).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (completed) {
+      await noSymlinkAncestors(destination);
+      if (!completed.isFile() || completed.size !== chunk.size || await digest(destination) !== chunk.sha256)
+        throw new WorkspaceError("artifact_changed", "An immutable artifact changed on the host");
+      return { filename: chunk.filename, sha256: chunk.sha256, size: chunk.size, nextOffset: chunk.size, complete: true };
+    }
+    const handle = await fs.open(temporary, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 384);
+    try {
+      const stat = await handle.stat();
+      if (!stat.isFile() || stat.size > chunk.size || chunk.offset > stat.size)
+        throw new WorkspaceError("artifact_offset_mismatch", "Artifact chunk is out of order");
+      const overlap = Math.min(bytes.length, stat.size - chunk.offset);
+      if (overlap) {
+        const existing = Buffer.alloc(overlap);
+        const read = await handle.read(existing, 0, overlap, chunk.offset);
+        if (read.bytesRead !== overlap || !existing.equals(bytes.subarray(0, overlap)))
+          throw new WorkspaceError("artifact_payload_mismatch", "Retried artifact bytes differ");
+      }
+      let written = overlap;
+      while (written < bytes.length) {
+        const result = await handle.write(bytes, written, bytes.length - written, chunk.offset + written);
+        if (!result.bytesWritten) throw new Error("Artifact write stopped");
+        written += result.bytesWritten;
+      }
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const size = (await fs.stat(temporary)).size;
+    if (chunk.seal) {
+      if (size !== chunk.size || await digest(temporary) !== chunk.sha256)
+        throw new WorkspaceError("artifact_digest_mismatch", "Artifact checksum is incomplete or invalid");
+      await fs.link(temporary, destination).catch((error) => {
+        if (error.code !== "EEXIST") throw error;
+      });
+      const directory = await fs.open(path.dirname(destination), "r");
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+      await fs.unlink(temporary);
+      return { filename: chunk.filename, sha256: chunk.sha256, size, nextOffset: size, complete: true };
+    }
+    return { filename: chunk.filename, sha256: chunk.sha256, size: chunk.size, nextOffset: size, complete: false };
+  }
+}
+async function digest(filename) {
+  const handle = await fs.open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const hash = createHash("sha256");
+    for await (const bytes of handle.createReadStream({ autoClose: false })) hash.update(bytes);
+    return hash.digest("hex");
+  } finally {
+    await handle.close();
+  }
+}
+export {
+  RESERVED_ARTIFACT_ENV,
+  SessionArtifactChunk,
+  SessionArtifactStore
+};