@ricsam/r5d-worker 0.0.54 → 0.0.56

package/README.md

@@ -17,11 +17,11 @@ Web shells and agent shell commands receive a server-issued `r5dctl` credential
 
 When the user has signed in with GitHub, web shells and agent commands also receive that OAuth credential through `GH_TOKEN`. GitHub CLI commands such as `gh pr`, `gh issue`, and `gh workflow` therefore use the signed-in user's permissions without a separate `gh auth login` on the worker host. Signing in again refreshes the granted OAuth scopes for subsequently started commands and shells.
 
-Visible branch checkouts are the user/agent workbench. Their `origin` remains the connected GitHub repository for manual Git work. r5d internal sync git metadata lives separately under `~/.r5d/sync`; when a worker connects, every idle registered branch is force-synchronized from that internal remote. The same destructive sync can be requested for a live worker from User Settings.
+Visible branch checkouts are the user/agent workbench. Their `origin` remains the connected GitHub repository for manual Git work. r5d internal sync git metadata lives separately under `~/.r5d/sync`; each worker periodically snapshots eligible working-tree changes and reconciles them with the canonical workspace like an independent Git client. Ordinary commands and shells may remain active while this happens. Compatible inbound changes are hydrated into the visible checkout, while paths changed locally since the snapshot are preserved for a later sync or conflict-remediation pass. Canonical remediation shells are the exception: they edit the hidden synchronization checkout directly and remain serialized with synchronization.
 
 Branch names managed by r5d use lowercase letters, numbers, internal hyphens, and slash-separated segments, for example `ft/esm-support`. They may contain at most 45 characters. On the first start after upgrading to the nested checkout layout, the worker atomically moves each unambiguous legacy `<namespace>-<project>` directory to `<namespace>/<project>`. If both paths exist, it preserves both and stops with recovery instructions.
 
-Worker protocol releases are breaking server/worker cutovers. Run any release-specific preflight and backfill against the production database, stop and upgrade workers to the required version, deploy the matching server, and then reconnect workers. Older workers are rejected before WebSocket upgrade rather than receiving incompatible target or manifest messages.
+Releases that change the worker protocol are explicitly documented as breaking server/worker cutovers. For those releases, run the release-specific preflight and backfill against the production database, stop and upgrade workers to the required version, deploy the matching server, and then reconnect workers. Older workers are rejected before WebSocket upgrade rather than receiving incompatible target or manifest messages. Protocol-compatible releases use the ordinary worker update flow.
 
 Worker labels are mandatory and unique per user. Choose labels that describe host capabilities, such as `macos`, `linux`, `ios`, or `ec2-build`.
 

package/dist/cjs/main.cjs

@@ -64,6 +64,7 @@ var import_heartbeat = require("./heartbeat.cjs");
 var import_process_tree = require("./process-tree.cjs");
 var import_port_forward_client = require("./port-forward-client.cjs");
 var import_workspace_incident_state = require("./workspace-incident-state.cjs");
+var import_workspace_command_sync_policy = require("./workspace-command-sync-policy.cjs");
 var import_supervisor = require("./supervisor.cjs");
 var import_managed_paths = require("./managed-paths.cjs");
 var import_workspace_sync = require("./workspace-sync.cjs");
@@ -2295,7 +2296,7 @@ async function openPty(input) {
       });
     },
     onExit: (event) => {
-      input.releaseWorkspaceMutation();
+      input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       sendWorkerMessage(input.ws, {
         type: "pty_exit",
@@ -2305,7 +2306,7 @@ async function openPty(input) {
       });
     },
     onError: (error) => {
-      input.releaseWorkspaceMutation();
+      input.releaseWorkspaceMutation?.();
       activePtys.delete(input.message.ptyId);
       sendWorkerMessage(input.ws, {
         type: "pty_error",
@@ -2318,7 +2319,7 @@ async function openPty(input) {
   activePtys.set(input.message.ptyId, {
     ...ptyProcess,
     target: input.resolvedTarget.target,
-    releaseWorkspaceMutation: input.releaseWorkspaceMutation
+    ...input.releaseWorkspaceMutation ? { releaseWorkspaceMutation: input.releaseWorkspaceMutation } : {}
   });
 }
 function writePty(ws, message) {
@@ -2864,14 +2865,20 @@ async function startWorker(options) {
           });
           return;
         }
-        const releaseWorkspaceMutation = await workspaceSyncSingleFlight.acquireMutation();
+        const releaseWorkspaceMutation = await (0, import_workspace_command_sync_policy.acquireWorkspaceCommandMutation)(message.target, workspaceSyncSingleFlight);
         let leaseTransferred = false;
         try {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}
 `);
-          await openPty({ ws, message, resolvedTarget, planRoot, releaseWorkspaceMutation });
-          leaseTransferred = true;
+          await openPty({
+            ws,
+            message,
+            resolvedTarget,
+            planRoot,
+            ...releaseWorkspaceMutation ? { releaseWorkspaceMutation } : {}
+          });
+          leaseTransferred = releaseWorkspaceMutation !== void 0;
         } catch (error) {
           sendWorkerMessage(ws, {
             type: "pty_error",
@@ -2880,7 +2887,7 @@ async function startWorker(options) {
             error: error instanceof Error ? error.message : String(error)
           });
         } finally {
-          if (!leaseTransferred) releaseWorkspaceMutation();
+          if (!leaseTransferred) releaseWorkspaceMutation?.();
         }
         return;
       }
@@ -2909,12 +2916,13 @@ async function startWorker(options) {
         }
         let result;
         try {
-          result = await workspaceSyncSingleFlight.runMutation(async () => {
+          const runCommand = async () => {
             const resolvedTarget = resolveMessageTarget(message.target);
             process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
 `);
             return await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
-          });
+          };
+          result = await (0, import_workspace_command_sync_policy.runWorkspaceCommand)(message.target, workspaceSyncSingleFlight, runCommand);
         } catch (error) {
           result = {
             type: "exec_result",
@@ -2943,7 +2951,7 @@ async function startWorker(options) {
           requestId: message.requestId,
           runId: message.runId
         });
-        void workspaceSyncSingleFlight.runMutation(async () => {
+        const runCommand = async () => {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] exec_start ${message.runId}: ${message.argv.join(" ")}
 `);
@@ -2956,7 +2964,9 @@ async function startWorker(options) {
             artifactRoot,
             planRoot
           });
-        }).catch((error) => {
+        };
+        const execution = (0, import_workspace_command_sync_policy.runWorkspaceCommand)(message.target, workspaceSyncSingleFlight, runCommand);
+        void execution.catch((error) => {
           sendWorkerMessage(ws, {
             type: "exec_start_error",
             requestId: message.requestId,

package/dist/cjs/package.json

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

package/dist/cjs/workspace-command-sync-policy.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workspace_command_sync_policy_exports = {};
+__export(workspace_command_sync_policy_exports, {
+  acquireWorkspaceCommandMutation: () => acquireWorkspaceCommandMutation,
+  runWorkspaceCommand: () => runWorkspaceCommand,
+  shouldSerializeWorkspaceCommand: () => shouldSerializeWorkspaceCommand
+});
+module.exports = __toCommonJS(workspace_command_sync_policy_exports);
+function shouldSerializeWorkspaceCommand(target) {
+  return target.type === "workspace" && target.rootProfile === "canonical_sync";
+}
+function runWorkspaceCommand(target, coordinator, operation) {
+  return shouldSerializeWorkspaceCommand(target) ? coordinator.runMutation(operation) : Promise.resolve().then(operation);
+}
+function acquireWorkspaceCommandMutation(target, coordinator) {
+  return shouldSerializeWorkspaceCommand(target) ? coordinator.acquireMutation() : Promise.resolve(void 0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acquireWorkspaceCommandMutation,
+  runWorkspaceCommand,
+  shouldSerializeWorkspaceCommand
+});