@runuai/host 0.9.149 → 0.9.151

package/lib/task-environment/workspace-runtime.fixture.ts

@@ -0,0 +1,50 @@
+/**
+ * Tests only: the task's runtime as a `RuntimeNamespace` (#cb3j0z), its
+ * workspace the host directory `root` mounted at /workspace. What it is asked
+ * to make, remove and link is recorded and done there. A path through a link
+ * the task made resolves inside the runtime, never to the host's own files,
+ * so nothing is done on the host for it.
+ */
+import { lstatSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { join, relative } from "node:path";
+
+import type { RuntimeNamespace } from "./workspace-files";
+
+/** Whether a runtime path below /workspace passes through a link before its
+ *  last component. */
+export function throughLink(root: string, path: string): boolean {
+  let at = root;
+  for (const part of relative("/workspace", path).split("/").slice(0, -1)) {
+    at = join(at, part);
+    try {
+      if (lstatSync(at).isSymbolicLink()) return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export function hostRuntimeNamespace(root: string, calls: string[][] = []): RuntimeNamespace {
+  const at = (path: string): string | null => (throughLink(root, path) ? null : join(root, relative("/workspace", path)));
+  return {
+    workspacePath: "/workspace",
+    makeDirectories: async (path) => {
+      calls.push(["mkdir", path]);
+      const host = at(path);
+      if (host) mkdirSync(host, { recursive: true });
+    },
+    remove: async (path) => {
+      calls.push(["rm", path]);
+      const host = at(path);
+      if (host) rmSync(host, { force: true });
+    },
+    replaceLink: async (target, path) => {
+      calls.push(["ln", target, path]);
+      const host = at(path);
+      if (!host) return;
+      rmSync(host, { force: true });
+      symlinkSync(target, host);
+    },
+  };
+}

package/lib/task-gateway-recovery.ts

@@ -24,8 +24,11 @@ export function recoverActiveTaskGateways(): TaskGatewayRecoverySummary {
       if (spec === null) {
         throw new Error("loader task has no persisted project env spec");
       }
+      // The generation serves the run its runtime was established for.
+      const runEpoch = task.runEpoch > 0 ? task.runEpoch : null;
       const identity = recoverTaskGatewayTask(task.taskId, {
-        resolveEnv: taskEnvResolver(task.taskId, spec),
+        resolveEnv: taskEnvResolver(task.taskId, spec, runEpoch),
+        runEpoch,
       });
       if (identity === null) {
         throw new Error("loader task has no valid persisted gateway identity");

package/lib/task-gateway-state.ts

@@ -44,6 +44,9 @@ interface TaskGatewayRecord {
   suspended: boolean;
   resolveEnv: TaskGatewayEnvResolver | null;
   snapshot: TaskGatewayEnvSnapshot | null;
+  /** ADR-154: the run this generation serves (null: one from before run
+   *  epochs). What its task's env and proxy are read for. */
+  runEpoch: number | null;
 }
 
 export interface TaskGatewayRegistration extends TaskForwarderIdentity {}
@@ -70,6 +73,8 @@ export interface ResolvedTaskGatewayEnv {
 export interface RegisterTaskGatewayOptions {
   resolveEnv?: TaskGatewayEnvResolver;
   snapshot?: TaskGatewayEnvSnapshot;
+  /** The run the generation serves; absent for one from before run epochs. */
+  runEpoch?: number | null;
 }
 
 type RevocationListener = (identity: TaskGatewayRegistration) => void;
@@ -153,6 +158,7 @@ function persistedRecord(taskId: string): TaskGatewayRecord | null {
       suspended: false,
       resolveEnv: null,
       snapshot: null,
+      runEpoch: null,
     };
   } catch {
     return null;
@@ -228,6 +234,7 @@ function assignEnv(
   }
   record.resolveEnv = options.resolveEnv ?? null;
   record.snapshot = options.snapshot ?? null;
+  record.runEpoch = options.runEpoch ?? null;
 }
 
 /** Mint and durably register a fresh task generation. */
@@ -254,6 +261,7 @@ export function registerTaskGatewayTask(
       suspended: false,
       resolveEnv: null,
       snapshot: null,
+      runEpoch: null,
     };
     assignEnv(record, options);
     records.set(taskId, record);
@@ -398,6 +406,13 @@ export function currentTaskGatewayRegistration(
     : null;
 }
 
+/** ADR-154: the run the task's live generation serves; null with none live,
+ *  or for one from before run epochs. */
+export function currentTaskGatewayRun(taskId: string): number | null {
+  const record = currentRecord(taskId);
+  return record?.active ? record.runEpoch : null;
+}
+
 /** Trusted recovery identity, available while public authentication is shut. */
 export function taskGatewayRegistrationForRecovery(
   taskId: string,