@runuai/host 0.9.167 → 0.9.169

package/lib/task-environment/types.ts

@@ -393,6 +393,11 @@ export function assertWorkspaceScopedPath(
   }
 }
 
+/** A malformed process request, distinct from provider/runtime failures. */
+export class TaskEnvironmentRequestValidationError extends Error {
+  override name = "TaskEnvironmentRequestValidationError";
+}
+
 const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 /** Shared admission guard for provider implementations and fake providers. */
@@ -402,7 +407,7 @@ const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 export function assertTaskEnvironmentExecRequest(request: TaskEnvironmentExecRequest): void {
   const { privileged, ...unprivileged } = request;
   if (privileged !== undefined && (privileged !== true || request.user !== "root")) {
-    throw new Error("a privileged task environment exec must run as root");
+    throw new TaskEnvironmentRequestValidationError("a privileged task environment exec must run as root");
   }
   assertTaskEnvironmentProcessRequest(unprivileged);
 }
@@ -412,7 +417,7 @@ export function assertTaskEnvironmentProcessRequest(
 ): void {
   assertTaskEnvironmentSessionRequest(request);
   if (!Number.isSafeInteger(request.timeoutMs) || request.timeoutMs <= 0) {
-    throw new Error("task environment timeout must be a positive integer");
+    throw new TaskEnvironmentRequestValidationError("task environment timeout must be a positive integer");
   }
 }
 
@@ -420,7 +425,7 @@ export function assertTaskEnvironmentProcessRequest(
  *  step without the capability it asked for. */
 export function refusePrivilegedExec(request: TaskEnvironmentExecRequest): void {
   if (request.privileged === true) {
-    throw new Error("this task environment provider has no privileged exec");
+    throw new TaskEnvironmentRequestValidationError("this task environment provider has no privileged exec");
   }
 }
 
@@ -434,13 +439,13 @@ export function assertTaskEnvironmentSessionRequest(
   // Only a one-shot exec may be privileged (assertTaskEnvironmentExecRequest
   // strips it after checking); anywhere else it is refused outright.
   if ("privileged" in request) {
-    throw new Error("only a one-shot task environment exec may be privileged");
+    throw new TaskEnvironmentRequestValidationError("only a one-shot task environment exec may be privileged");
   }
   if (
     request.projectEnvProfile !== "maintenance" &&
     request.projectEnvProfile !== "task"
   ) {
-    throw new Error(
+    throw new TaskEnvironmentRequestValidationError(
       "task environment project env profile must be maintenance or task",
     );
   }
@@ -451,19 +456,19 @@ export function assertTaskEnvironmentSessionRequest(
       (part) => typeof part !== "string" || part.length === 0 || part.includes("\0"),
     )
   ) {
-    throw new Error("task environment argv must contain nonempty NUL-free strings");
+    throw new TaskEnvironmentRequestValidationError("task environment argv must contain nonempty NUL-free strings");
   }
   if (
     request.cwd !== undefined &&
-    (!request.cwd.startsWith("/") || request.cwd.includes("\0"))
+    (typeof request.cwd !== "string" || !request.cwd.startsWith("/") || request.cwd.includes("\0"))
   ) {
-    throw new Error("task environment cwd must be an absolute NUL-free path");
+    throw new TaskEnvironmentRequestValidationError("task environment cwd must be an absolute NUL-free path");
   }
   if (
     request.user !== undefined &&
-    (request.user.length === 0 || request.user.includes("\0"))
+    (typeof request.user !== "string" || request.user.length === 0 || request.user.includes("\0"))
   ) {
-    throw new Error("task environment user must be a nonempty NUL-free value");
+    throw new TaskEnvironmentRequestValidationError("task environment user must be a nonempty NUL-free value");
   }
   if (
     request.anchor !== undefined &&
@@ -474,7 +479,7 @@ export function assertTaskEnvironmentSessionRequest(
         (part) => typeof part !== "string" || part.length === 0 || part.includes("\0"),
       ))
   ) {
-    throw new Error("a task environment anchor must be a NUL-free argv for a task user's process");
+    throw new TaskEnvironmentRequestValidationError("a task environment anchor must be a NUL-free argv for a task user's process");
   }
   if (
     request.inheritEnv !== undefined &&
@@ -485,7 +490,7 @@ export function assertTaskEnvironmentSessionRequest(
         (name) => typeof name !== "string" || !ENV_NAME.test(name),
       ))
   ) {
-    throw new Error("task environment inherited env names are invalid");
+    throw new TaskEnvironmentRequestValidationError("task environment inherited env names are invalid");
   }
   for (const [name, value] of Object.entries(request.env ?? {})) {
     if (
@@ -493,21 +498,21 @@ export function assertTaskEnvironmentSessionRequest(
       typeof value !== "string" ||
       value.includes("\0")
     ) {
-      throw new Error("task environment env must contain valid NUL-free entries");
+      throw new TaskEnvironmentRequestValidationError("task environment env must contain valid NUL-free entries");
     }
   }
   if (
     !Number.isSafeInteger(request.maxOutputBytes) ||
     request.maxOutputBytes <= 0
   ) {
-    throw new Error("task environment output limit must be a positive integer");
+    throw new TaskEnvironmentRequestValidationError("task environment output limit must be a positive integer");
   }
   if (
     "launchTimeoutMs" in request &&
     (!Number.isSafeInteger(request.launchTimeoutMs) ||
       request.launchTimeoutMs <= 0)
   ) {
-    throw new Error(
+    throw new TaskEnvironmentRequestValidationError(
       "task environment detached launch timeout must be a positive integer",
     );
   }

package/lib/task-project-ops-host.ts

@@ -0,0 +1,147 @@
+/**
+ * ADR-161 §2: the live-project commands wired to this runner's real state —
+ * the task's persisted environment, its run-epoch admission, its lifecycle
+ * slot, its lease grant and env replica, and its persisted env spec.
+ */
+
+import { activeCloudCredentials, credentialsMode } from "./cloud-credential-host";
+import { getOrchestrator } from "./orchestrator";
+import {
+  getHostTask,
+  hostTaskProjectEnvSpec,
+  readTaskRunEpochState,
+  taskProjectEnvSpec,
+  upsertHostTask,
+  type TaskProjectEnvSpec,
+} from "./runtime-state";
+import { taskUaiDir } from "./env";
+import { captureTaskEnvSchemaFromClone, taskEnvSchemaObservation } from "./project-env-schema-capture";
+import { reconstructPersistedTaskEnvironment } from "./task-environment";
+import { forgetTaskEnvSnapshot, taskEnvResolver } from "./task-env-source";
+import { currentTaskGatewayRegistration, setTaskGatewayEnvResolver } from "./task-gateway-state";
+import { TaskProjectJournalStore, TaskProjectOps } from "./task-project-ops";
+import type { TaskCommandProject } from "../src/protocol";
+
+function runIsCurrent(taskId: string, runEpoch: number): boolean {
+  const task = getHostTask(taskId);
+  if (!task || task.statusMirror !== "running") return false;
+  const state = readTaskRunEpochState(taskId);
+  // A task started before run epochs carries none; the cloud never sends
+  // these commands to it (it has no `live-task-projects-v1` contract).
+  return state !== null && state.assignmentOpen && state.highestRunEpoch === runEpoch;
+}
+
+/** Names the cloud's literal channel must never set live: the editor theme
+ *  is the task's, chosen at start. */
+const RESERVED_LITERAL_ENV = new Set(["UAI_EDITOR_THEME"]);
+
+/**
+ * One project (and its preview URL literals) added to a persisted env spec.
+ * Every other entry stays; a literal name the task already has keeps its
+ * value, as at start where the first project to declare one wins.
+ */
+export function specWithProject(
+  spec: TaskProjectEnvSpec,
+  project: TaskCommandProject,
+  previewEnv: Record<string, string> = {},
+): TaskProjectEnvSpec {
+  const hasProject = spec.projects.some((entry) => entry.projectId === project.id);
+  const addedLiterals = Object.entries(previewEnv).filter(
+    ([name]) => !RESERVED_LITERAL_ENV.has(name) && !(name in spec.previewEnv),
+  );
+  if (hasProject && addedLiterals.length === 0) return spec;
+  const [entry] = taskProjectEnvSpec({
+    projects: [project],
+    task: { previewEnv: {} } as Parameters<typeof taskProjectEnvSpec>[0]["task"],
+  }).projects;
+  return {
+    ...spec,
+    projects: hasProject
+      ? spec.projects
+      : [...spec.projects, entry!].sort(
+          (left, right) => left.position - right.position || left.projectId.localeCompare(right.projectId),
+        ),
+    previewEnv: Object.fromEntries(
+      [...Object.entries(spec.previewEnv), ...addedLiterals].sort(([left], [right]) => left.localeCompare(right)),
+    ),
+  };
+}
+
+function liveProjectsSupported(taskId: string): boolean {
+  const task = getHostTask(taskId);
+  if (!task) return false;
+  try {
+    return hostTaskProjectEnvSpec(task) !== null && currentTaskGatewayRegistration(taskId) !== null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Persist the extended spec, then ALWAYS re-point the live resolver at the
+ * persisted spec, so a repeat repairs a resolver a crash left behind. Throws
+ * when the environment can't take it; Activate then answers `incomplete`.
+ */
+function installProjectEnv(
+  taskId: string,
+  runEpoch: number,
+  project: TaskCommandProject,
+  previewEnv: Record<string, string>,
+): void {
+  const task = getHostTask(taskId);
+  if (!task) throw new Error(`no such task: ${taskId}`);
+  const spec = hostTaskProjectEnvSpec(task);
+  if (spec === null) throw new Error("this task has no persisted env spec to extend");
+  const registration = currentTaskGatewayRegistration(taskId);
+  if (!registration) throw new Error("this task has no live env gateway");
+  const next = specWithProject(spec, project, previewEnv);
+  if (next !== spec) upsertHostTask(taskId, { projectEnvSpec: JSON.stringify(next) });
+  forgetTaskEnvSnapshot(taskId);
+  if (!setTaskGatewayEnvResolver(taskId, registration.generation, taskEnvResolver(taskId, next, runEpoch))) {
+    throw new Error("the task's env gateway changed while the project was installed");
+  }
+}
+
+let singleton: TaskProjectOps | null = null;
+
+export function taskProjectOps(): TaskProjectOps {
+  singleton ??= new TaskProjectOps({
+    journal: new TaskProjectJournalStore(taskUaiDir),
+    environment: async (taskId) => {
+      const task = getHostTask(taskId);
+      if (!task || task.statusMirror !== "running") return null;
+      return reconstructPersistedTaskEnvironment(task);
+    },
+    runIsCurrent,
+    inLifecycleSlot: (taskId, fn) => getOrchestrator().runTaskLifecycle(taskId, fn),
+    credentials: () => (credentialsMode() === "active" ? "cloud" : "own"),
+    installedGrant: (taskId, runEpoch) => {
+      const composer = activeCloudCredentials();
+      if (!composer) return null;
+      const view = composer.registry.currentView({ taskId, runEpoch });
+      return view
+        ? { runEpoch, manifestRevision: view.manifestRevision, manifestDigest: view.manifestDigest }
+        : null;
+    },
+    envServes: (taskId, runEpoch, projectId) => {
+      const composer = activeCloudCredentials();
+      // The runner's own store serves every project it holds values for.
+      if (!composer) return true;
+      const view = composer.registry.currentView({ taskId, runEpoch });
+      if (!view || !view.projectIds.includes(projectId)) return false;
+      return composer.envSnapshot({ taskId, runEpoch }, view.projectIds) !== null;
+    },
+    liveProjectsSupported,
+    captureEnvSchema: (taskId, projectId, git) => captureTaskEnvSchemaFromClone(taskId, projectId, git),
+    storedEnvSchema: (taskId, projectId) => taskEnvSchemaObservation(taskId, projectId),
+    servedProjectIds: (taskId, runEpoch) => {
+      const composer = activeCloudCredentials();
+      if (!composer) return null;
+      const view = composer.registry.currentView({ taskId, runEpoch });
+      if (!view) return null;
+      return composer.envSnapshot({ taskId, runEpoch }, view.projectIds) !== null ? [...view.projectIds] : null;
+    },
+    installProjectEnv,
+  });
+  return singleton;
+}