@ricsam/r5d-worker 0.0.157 → 0.0.158

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.157",
+  "version": "0.0.158",
   "type": "commonjs"
 }

package/dist/mjs/internal-r5dctl.cjs

@@ -20605,7 +20605,7 @@ function resolveEntrypointPath(entrypoint) {
   }
 }
 function getR5dctlVersion() {
-  if (true) return "0.0.157";
+  if (true) return "0.0.158";
   const entrypoint = process.argv[1] ? resolveEntrypointPath(process.argv[1]) : null;
   let current = entrypoint ? import_node_path2.default.dirname(entrypoint) : process.cwd();
   for (let index = 0; index < 12; index += 1) {

package/dist/mjs/main.mjs

@@ -7,7 +7,7 @@ import { startManagerRpc } from "./runtime/releases/rpc-main.mjs";
 import { ManagerRpcConfig } from "./runtime/releases/rpc-protocol.mjs";
 const args = process.argv.slice(2);
 if (args.includes("--version")) {
-  console.log(`r5d-worker ${true ? "0.0.157" : "development"}`);
+  console.log(`r5d-worker ${true ? "0.0.158" : "development"}`);
 } else if (!args.length || args.includes("--help")) {
   console.log(
     "Usage: r5d-worker start --label <label> [--root <dir>] [--base-url <url>] [--token <worker-token>]\n       r5d-worker executor /absolute/private/config.json\n       r5d-worker manager /absolute/private/config.json\n\nRun independently supervised durable runtime services. Provision configuration with r5dinfra."
@@ -15,7 +15,7 @@ if (args.includes("--version")) {
 } else if (args[0] === "start") {
   const runtime = await startPersonalWorker(
     parsePersonalWorkerOptions(args.slice(1)),
-    true ? "0.0.157" : "development"
+    true ? "0.0.158" : "development"
   );
   console.log(`Worker connected: ${runtime.resourceId}`);
   let closing = false;

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.157",
+  "version": "0.0.158",
   "type": "module"
 }

package/dist/mjs/personal/client.mjs

@@ -125,6 +125,9 @@ async function startPersonalWorker(options, version) {
           throw new WorkspaceError(error.code, "Scoped storage rejected the request; retain its original operation identity", error.rejectedBeforeAdmission);
         throw error;
       }
+    },
+    publicationReport: async (report) => {
+      await request(`${endpoint}/publication`, { instanceId: identity.instanceId, report });
     }
   });
   const ledgerFile = path.join(root, "relay.sqlite");

package/dist/mjs/personal/runtime.mjs

@@ -1,9 +1,9 @@
 import path from "node:path";
 import { PersonalTcpManager } from "./tcp.mjs";
-import { createHash, randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { z } from "zod";
-import { RuntimeHello, RuntimeId, OwnershipFence, OperationEnvelope, canonicalJson } from "@ricsam/r5d-api/runtime-protocol";
+import { RuntimeHello, RuntimeId, OwnershipFence, OperationEnvelope, WorkspacePublicationReport, canonicalJson } from "@ricsam/r5d-api/runtime-protocol";
 import { startHostExecutor } from "../runtime/daemon.mjs";
 import { HostExecutorClient } from "../runtime/client.mjs";
 import { tokenHash } from "../runtime/executor.mjs";
@@ -42,7 +42,8 @@ const PersonalWorkspaceRequest = z.object({
   sharedWorkbenches: z.array(Workbench).max(32).optional(),
   kind: z.enum(["inspect", "terminal", "product", "agent", "tcp"]),
   command: z.record(z.string(), z.unknown()),
-  credentials: z.array(ExecutorCredential).max(32).optional()
+  credentials: z.array(ExecutorCredential).max(32).optional(),
+  remediation: z.literal(true).optional()
 }).strict();
 async function personalExecutorToken(root, grant) {
   const identity = { installationId: grant.installationId, userId: grant.userId, resourceId: grant.resourceId, instanceId: grant.instanceId, workerId: grant.workerFence.resourceId };
@@ -252,6 +253,18 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         }
       }
     }
+    const blockedPublicationCodes = /* @__PURE__ */ new Set([
+      "ignore_policy",
+      "secret_or_runtime_path",
+      "secret_content",
+      "unsafe_file",
+      "unsafe_git",
+      "unsafe_path",
+      "unsafe_tree",
+      "too_large"
+    ]);
+    const conflictPublicationCodes = /* @__PURE__ */ new Set(["conflict", "workbench_conflict"]);
+    const failedPublicationAttempts = /* @__PURE__ */ new Map();
     let publication = null, closing = false;
     const synchronize = () => {
       if (publication) return publication;
@@ -263,10 +276,43 @@ exec ${quote(executable)} ${quote(cli)} "$@"
           if (!manifest || manifest.rootProfile !== "project") continue;
           try {
             const result = await authority.publish({ userId: grant.userId, sessionId });
+            failedPublicationAttempts.delete(workbenchId);
             results.push({ workbenchId, ...result });
           } catch (error) {
             const code = error instanceof WorkspaceError ? error.code : "publication_failed";
             results.push({ workbenchId, error: code });
+            if (code !== "not_initialized" && options.publicationReport) {
+              let startingHead = null;
+              try {
+                const status = await authority.status({ userId: grant.userId, sessionId });
+                startingHead = status.head;
+              } catch {
+              }
+              const outcome = conflictPublicationCodes.has(code) ? "conflict_blocked" : blockedPublicationCodes.has(code) ? "large_diff_blocked" : "failed";
+              const fingerprint = canonicalJson({ code, startingHead, outcome });
+              let attempt = failedPublicationAttempts.get(workbenchId);
+              if (!attempt || attempt.fingerprint !== fingerprint) {
+                attempt = { fingerprint, attemptId: randomUUID() };
+                failedPublicationAttempts.set(workbenchId, attempt);
+              }
+              try {
+                await options.publicationReport(WorkspacePublicationReport.parse({
+                  protocol: 1,
+                  attemptId: attempt.attemptId,
+                  sessionId,
+                  workbenchId,
+                  repositoryId: manifest.repositoryId,
+                  branch: manifest.branch,
+                  outcome,
+                  startingHead,
+                  diffSizeBytes: outcome === "large_diff_blocked" && code === "too_large" ? 5 * 1024 * 1024 + 1 : 0,
+                  error: code
+                }));
+              } catch (reportError) {
+                process.stderr.write(`[r5d-worker] publication report deferred: ${reportError instanceof WorkspaceError ? reportError.code : "publication_report_failed"}
+`);
+              }
+            }
           }
         }
         return results;
@@ -335,7 +381,8 @@ exec ${quote(executable)} ${quote(cli)} "$@"
                   ...command.method === "open" ? { interactive: true, pty: { cols: command.cols, rows: command.rows } } : {},
                   credentials: (request.credentials ?? []).map(({ id, generation }) => ({ id, generation }))
                 }
-              })
+              }),
+              request.remediation === true
             ),
             workerLabel: grant.label ?? grant.resourceId
           };
@@ -350,7 +397,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
       if (request.kind === "product") {
         if (command.method === "fileWrite") {
           await authority.ensureHydrated(identity);
-          return authority.fileWrite(identity, command);
+          return authority.fileWrite(identity, command, request.remediation === true);
         }
         if (command.method === "materializeArtifact") return authority.materializeArtifact(identity, command);
         if (command.method === "seed") return authority.seedReadme(identity, command.readme);
@@ -362,7 +409,10 @@ exec ${quote(executable)} ${quote(cli)} "$@"
         if (command.method === "commit") return authority.commit(identity, command);
         if (command.method === "push") return authority.push(identity, command);
         if (command.method === "reset") return authority.reset(identity, command);
-        if (command.method === "publish") return authority.publish(identity);
+        if (command.method === "publish") return authority.publish(identity, {
+          allowLargeDiff: request.remediation === true && command.allowLargeDiff === true,
+          allowBlockedConflict: request.remediation === true
+        });
         if (command.method === "reconcilePublication") return authority.reconcilePublication(identity);
       }
       if (request.kind === "agent") {
@@ -387,7 +437,7 @@ exec ${quote(executable)} ${quote(cli)} "$@"
               cwd: manifests.get(routes.get(identity.sessionId)).cwd,
               credentials: (request.credentials ?? []).map(({ id, generation }) => ({ id, generation }))
             }
-          });
+          }, request.remediation === true);
         }
         if (command.method === "poll")
           return authority.poll(identity, run(command.run.operationId), command.stdoutOffset, command.stderrOffset, command.maxBytes);

package/dist/mjs/runtime/workspace/authority.mjs

@@ -866,15 +866,18 @@ class WorkspaceAuthority {
       return { state: "completed", result: receipt.result };
     });
   }
-  async fileWrite(identity, raw) {
+  async fileWrite(identity, raw, allowBlockedConflict = false) {
     const input = WorkspaceFileWrite.parse(raw), bytes = Buffer.from(input.base64, "base64");
     if (bytes.toString("base64") !== input.base64 || bytes.length > 768 * 1024)
       throw new WorkspaceError("invalid_input", "Expected canonical base64 for at most 768 KiB", true);
     const b = await this.bench(identity), target = input.hostPath ? this.resolveHostPath(input.path) : path.join(b.config.cwd, input.path);
     const fingerprint = { ...input, userId: identity.userId, sessionId: identity.sessionId };
     let mode = 420;
+    let retainedBlock = null;
     const check = async () => {
-      if (b.state.blocked) throw new WorkspaceError(b.state.blocked.code, b.state.blocked.message);
+      if (b.state.blocked && !(allowBlockedConflict && (b.state.blocked.code === "conflict" || b.state.blocked.code === "workbench_conflict")))
+        throw new WorkspaceError(b.state.blocked.code, b.state.blocked.message);
+      retainedBlock = b.state.blocked;
       if (!b.state.initialized) throw new WorkspaceError("uninitialized", "Hydrate this workspace before writing files");
       let current = input.hostPath ? path.parse(target).root : b.config.cwd;
       const parentParts = (input.hostPath ? target.slice(current.length) : input.path).split(path.sep).filter(Boolean).slice(0, -1);
@@ -936,7 +939,7 @@ class WorkspaceAuthority {
         };
       }, check);
       if (b.state.blocked?.code === "file_write_unknown" && b.state.blocked.operationId === input.id) {
-        b.state.blocked = null;
+        b.state.blocked = retainedBlock;
         await this.save(b);
       }
       return result;
@@ -1167,15 +1170,16 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
       return { ...result, reset: true, retained: true };
     }));
   }
-  async publish(identity) {
+  async publish(identity, options = {}) {
     const b = await this.bench(identity);
     if (b.config.rootProfile === "account") return { head: "", unchanged: true };
     return this.serial(b, async () => {
-      await this.assertAvailable(b);
-      return this.publishIdle(b, identity);
+      const conflictBlocked = b.state.blocked?.code === "conflict" || b.state.blocked?.code === "workbench_conflict";
+      await this.assertAvailable(b, options.allowBlockedConflict === true && conflictBlocked);
+      return this.publishIdle(b, identity, "Destination workspace snapshot", options.allowLargeDiff === true);
     });
   }
-  async publishIdle(b, identity, message = "Destination workspace snapshot") {
+  async publishIdle(b, identity, message = "Destination workspace snapshot", allowLargeDiff = false) {
     if (!b.state.initialized) throw new WorkspaceError("not_initialized", "Hydrate or explicitly seed first");
     const storage = await this.storage(b, identity);
     const latest = await storage.read({
@@ -1194,6 +1198,19 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
     const tree = await snapshotTree(b.repo, b.config.cwd, b.state.head);
     if (b.state.head && tree === (await git(b.repo, ["rev-parse", `${b.state.head}^{tree}`])).toString().trim())
       return { head: b.state.head, unchanged: true };
+    if (!allowLargeDiff) {
+      const base = b.state.head ?? (await git(b.repo, ["hash-object", "-t", "tree", "--stdin"], "")).toString().trim();
+      let diff;
+      try {
+        diff = await git(b.repo, ["diff", "--binary", "--no-ext-diff", "--no-textconv", base, tree]);
+      } catch (error) {
+        if (error instanceof WorkspaceError && error.code === "git_failed")
+          throw new WorkspaceError("too_large", "Source diff exceeds the 5242880-byte automatic publication limit");
+        throw error;
+      }
+      if (diff.length > 5 * 1024 * 1024)
+        throw new WorkspaceError("too_large", "Source diff exceeds the 5242880-byte automatic publication limit");
+    }
     const commit = (await git(b.repo, ["commit-tree", tree, ...b.state.head ? ["-p", b.state.head] : []], `${message}
 `)).toString().trim();
     await git(b.repo, ["update-ref", this.canonicalRef(b), commit]);
@@ -1312,11 +1329,12 @@ ${DEFAULT_WORKSPACE_IGNORE}`, { mode: 384 });
     return this.serial(b, () => new SessionArtifactStore(this.config.workspaceRoot ?? this.config.root).materialize(identity, input));
   }
   /** Default arbitrary shell is mutating. Exact trusted config approval is the sole exemption. */
-  async start(identity, input) {
+  async start(identity, input, allowBlockedConflict = false) {
     const b = await this.bench(identity);
     const operation = OperationEnvelope.parse(JSON.parse(canonicalJson(input)));
     return this.serial(b, async () => {
-      if (!b.state.initialized || b.state.blocked)
+      const conflictBlocked = b.state.blocked?.code === "conflict" || b.state.blocked?.code === "workbench_conflict";
+      if (!b.state.initialized || b.state.blocked && !(allowBlockedConflict && conflictBlocked))
         throw new WorkspaceError("workbench_blocked", b.state.blocked?.message ?? "Initialize workbench first");
       if (operation.installationId !== this.config.installationId || operation.userId !== identity.userId || operation.sessionId !== identity.sessionId || operation.kind !== "host.shell")
         throw new WorkspaceError("forbidden", "Shell identity does not match approved workbench");

package/dist/mjs/runtime/workspace/files.mjs

@@ -254,7 +254,13 @@ async function materializeTree(repo, destination, entries, limit, message) {
   }
 }
 async function verifyIgnore(repo, cwd) {
-  await readRegular(path.join(cwd, ".gitignore"), 64 * 1024);
+  try {
+    await readRegular(path.join(cwd, ".gitignore"), 64 * 1024);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      throw new WorkspaceError("ignore_policy", "Restore an effective .gitignore before publishing source");
+    throw error;
+  }
   const probes = [
     ".env",
     ".env.local",
@@ -276,7 +282,7 @@ async function verifyIgnore(repo, cwd) {
   if (ignored.length !== probes.length || probes.some((p) => !ignored.includes(p)))
     throw new WorkspaceError("ignore_policy", "Restore effective .gitignore rules for secrets, dependency, cache and runtime roots");
 }
-async function snapshotTree(repo, cwd, canonicalHead) {
+async function snapshotTree(repo, cwd, canonicalHead, maxBytes = 128 * 1024 * 1024) {
   const metadata = path.join(cwd, ".git");
   let workbenchIndex = null;
   if (await fs.lstat(metadata).then(
@@ -328,15 +334,16 @@ async function snapshotTree(repo, cwd, canonicalHead) {
   }
   const canonical = canonicalHead ? await selectedTree(repo, canonicalHead) : [];
   const indexedGitlinks = /* @__PURE__ */ new Map();
+  const indexedFiles = /* @__PURE__ */ new Set();
   if (workbenchIndex) {
     const indexed = await git(repo, ["ls-files", "--stage", "-z"], void 0, workbenchIndex);
     if (!Buffer.from(indexed.toString()).equals(indexed)) throw new WorkspaceError("unsafe_path", "Non-UTF8 index names unsupported");
     for (const record of indexed.toString().split("\0").filter(Boolean)) {
-      const match = /^160000 ([0-9a-f]{40}) 0\t(.+)$/.exec(record);
-      if (record.startsWith("160000 ") && !match) throw new WorkspaceError("unsafe_tree", "Malformed gitlink index entry");
-      if (!match) continue;
-      sourcePath(match[2]);
-      indexedGitlinks.set(match[2], match[1]);
+      const match = /^(100644|100755|160000) ([0-9a-f]{40}) 0\t(.+)$/.exec(record);
+      if (!match) throw new WorkspaceError("unsafe_tree", "Malformed workbench index entry");
+      sourcePath(match[3]);
+      if (match[1] === "160000") indexedGitlinks.set(match[3], match[2]);
+      else indexedFiles.add(match[3]);
     }
   }
   const canonicalGitlinks = new Map(canonical.filter((entry) => entry.mode === "160000").map((entry) => [entry.file, entry.oid]));
@@ -363,7 +370,6 @@ async function snapshotTree(repo, cwd, canonicalHead) {
     if (nested) gitlinks.delete(file);
     else gitlinkRoots.push(file);
   }
-  await verifyIgnore(repo, cwd);
   await git(repo, ["read-tree", "--empty"]);
   const listing = await git(repo, [
     `--work-tree=${cwd}`,
@@ -385,7 +391,7 @@ async function snapshotTree(repo, cwd, canonicalHead) {
       current = parent;
     }
   };
-  const tracked = canonical.filter((entry) => entry.mode !== "160000").map((entry) => entry.file);
+  const tracked = [.../* @__PURE__ */ new Set([...canonical.filter((entry) => entry.mode !== "160000").map((entry) => entry.file), ...indexedFiles])];
   const existingTracked = [];
   for (const file of tracked) {
     const exists = await fs.lstat(path.join(cwd, file)).then(() => true, (error) => {
@@ -395,6 +401,8 @@ async function snapshotTree(repo, cwd, canonicalHead) {
     if (exists) existingTracked.push(file);
   }
   const files = [.../* @__PURE__ */ new Set([...listing.toString().split("\0").filter(Boolean), ...existingTracked])].filter((file) => !beneathGitlink(file)).sort();
+  if (files.some((file) => file.split("/").some((part) => part.toLowerCase() === "node_modules")))
+    throw new WorkspaceError("too_large", "An unignored dependency tree exceeds the automatic publication limit");
   if (files.length + gitlinks.size > STORAGE_LIMITS.treeEntries) throw new WorkspaceError("too_large", "Too many source files");
   let size = 0;
   const records = [...gitlinks].map(([file, oid]) => ({
@@ -405,12 +413,14 @@ async function snapshotTree(repo, cwd, canonicalHead) {
     sourcePath(file);
     const bytes = await readRegular(path.join(cwd, file));
     sourceBytes(bytes, file);
-    if ((size += bytes.length) > 128 * 1024 * 1024) throw new WorkspaceError("too_large", "Source snapshot exceeds 128 MiB");
+    if ((size += bytes.length) > maxBytes)
+      throw new WorkspaceError("too_large", `Source snapshot exceeds the ${maxBytes}-byte automatic publication limit`);
     const st = await fs.lstat(path.join(cwd, file));
     const oid = (await git(repo, ["hash-object", "-w", "--stdin", "--no-filters"], bytes)).toString().trim();
     records.push({ file, value: `${st.mode & 73 ? "100755" : "100644"} ${oid}	${file}\0` });
   }
   if (!files.includes(".gitignore")) throw new WorkspaceError("ignore_policy", "The .gitignore policy itself must be published");
+  await verifyIgnore(repo, cwd);
   await git(repo, ["update-index", "-z", "--index-info"], records.sort((a, b) => a.file.localeCompare(b.file)).map((record) => record.value).join(""));
   return (await git(repo, ["write-tree"])).toString().trim();
 }

package/dist/types/personal/runtime.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { WorkspacePublicationReport } from "@ricsam/r5d-api/runtime-protocol";
 import { WorkspaceAuthority } from "../runtime/workspace/authority";
 import { type StorageTransport } from "../runtime/workspace/storage-client";
 export declare const PersonalWorkerGrant: z.ZodObject<{
@@ -96,6 +97,7 @@ export declare const PersonalWorkspaceRequest: z.ZodObject<{
         env: z.ZodRecord<z.ZodString, z.ZodString>;
         files: z.ZodRecord<z.ZodString, z.ZodString>;
     }, z.core.$strict>>>;
+    remediation: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 export type PersonalWorkerRuntime = Awaited<ReturnType<typeof openPersonalWorkerRuntime>>;
 /** The host owns this keeper independently of every replaceable remote web/gateway generation. */
@@ -106,6 +108,9 @@ export declare function openPersonalWorkerRuntime(options: {
     cliEntrypoint?: string;
     /** Internal test/embedding override. Personal workers publish every minute. */
     publicationIntervalMs?: number;
+    /** Authenticated transport for autonomous publication evidence. Failures are
+     * retried with the same attempt identity on the next publication cycle. */
+    publicationReport?: (report: z.infer<typeof WorkspacePublicationReport>) => Promise<void>;
 }): Promise<{
     grant: {
         [x: string]: unknown;

package/dist/types/runtime/workspace/authority.d.ts

@@ -256,7 +256,7 @@ export declare class WorkspaceAuthority {
         state: "completed";
         result: any;
     }>;
-    fileWrite(identity: WorkspaceIdentity, raw: WorkspaceFileWrite): Promise<{
+    fileWrite(identity: WorkspaceIdentity, raw: WorkspaceFileWrite, allowBlockedConflict?: boolean): Promise<{
         intentHash?: string | undefined;
         method: string;
         id: string;
@@ -323,7 +323,10 @@ export declare class WorkspaceAuthority {
         retained: boolean;
         head: string;
     }>;
-    publish(identity: WorkspaceIdentity): Promise<{
+    publish(identity: WorkspaceIdentity, options?: {
+        allowLargeDiff?: boolean;
+        allowBlockedConflict?: boolean;
+    }): Promise<{
         head: string;
         unchanged?: boolean;
     }>;
@@ -347,7 +350,7 @@ export declare class WorkspaceAuthority {
         complete: boolean;
     }>;
     /** Default arbitrary shell is mutating. Exact trusted config approval is the sole exemption. */
-    start(identity: WorkspaceIdentity, input: OperationEnvelope): Promise<import("..").RunReceipt>;
+    start(identity: WorkspaceIdentity, input: OperationEnvelope, allowBlockedConflict?: boolean): Promise<import("..").RunReceipt>;
     private runRoute;
     private action;
     poll(identity: WorkspaceIdentity, run: RunIdentity, stdoutOffset?: number, stderrOffset?: number, maxBytes?: number): Promise<PollResult>;

package/dist/types/runtime/workspace/files.d.ts

@@ -26,4 +26,4 @@ export type TreeEntry = {
 export declare function selectedTree(repo: string, commit: string): Promise<TreeEntry[]>;
 export declare function materializeTree(repo: string, destination: string, entries: TreeEntry[], limit: number, message: string): Promise<void>;
 export declare function verifyIgnore(repo: string, cwd: string): Promise<void>;
-export declare function snapshotTree(repo: string, cwd: string, canonicalHead?: string | null): Promise<string>;
+export declare function snapshotTree(repo: string, cwd: string, canonicalHead?: string | null, maxBytes?: number): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.157",
+  "version": "0.0.158",
   "type": "module",
   "main": "./dist/mjs/main.mjs",
   "module": "./dist/mjs/main.mjs",
@@ -21,7 +21,7 @@
     "r5d-worker": "dist/mjs/main.mjs"
   },
   "dependencies": {
-    "@ricsam/r5d-api": "^0.0.157",
+    "@ricsam/r5d-api": "^0.0.158",
     "node-pty": "1.1.0",
     "zod": "^4.1.13",
     "picomatch": "^4.0.3"