@moondeck/station 0.0.1 → 1.0.0

package/lib/task-person-credentials.ts

@@ -0,0 +1,76 @@
+/**
+ * Restore GitHub/SSH files when a running task's cloud credentials become
+ * usable, after recovery or a live change. The persisted provider locator
+ * is the only runtime authority; a missing runtime is a retryable failure.
+ * Fresh task-up uses the same writer on its newly provisioned handle.
+ */
+import type { HostTask } from "../db/schema";
+import { CredentialLeaseUnavailableError, type TaskAssignment } from "./cloud-credential-leases";
+import { writeTaskPersonCredentials, type PersonCredentialLane } from "./credential-consumers/github";
+import type { TaskWriteEnvironment } from "./credential-consumers/task-files";
+import { getHostTask, readTaskRunEpochState } from "./runtime-state";
+import { reconstructPersistedTaskEnvironment } from "./task-environment";
+
+/**
+ * The composer retries a rejection while the same material is current and
+ * aborts this signal before cleanup or takeover. In particular, a fresh
+ * task that is still starting must retry: a rotation after its runtime-ready
+ * writes but before it is marked running must not be silently missed.
+ */
+export async function reconcileRunningTaskPersonCredentials(
+  assignment: Readonly<TaskAssignment>,
+  lanes: readonly PersonCredentialLane[],
+  signal: AbortSignal,
+): Promise<void> {
+  const current = (): HostTask => {
+    signal.throwIfAborted();
+    const task = getHostTask(assignment.taskId);
+    const run = readTaskRunEpochState(assignment.taskId);
+    if (
+      task === null ||
+      task.statusMirror !== "running" ||
+      task.runEpoch !== assignment.runEpoch ||
+      run === null ||
+      !run.assignmentOpen ||
+      run.highestRunEpoch !== assignment.runEpoch ||
+      run.runtimeEstablishedEpoch !== assignment.runEpoch
+    ) {
+      throw new CredentialLeaseUnavailableError("the task's running credential assignment is not current");
+    }
+    return task;
+  };
+  const task = current();
+  const assertCurrent = (): void => {
+    const live = current();
+    if (
+      live.environmentProvider !== task.environmentProvider ||
+      live.environmentLocator !== task.environmentLocator ||
+      live.envMode !== task.envMode
+    ) {
+      throw new CredentialLeaseUnavailableError("the task's credential runtime has changed");
+    }
+  };
+  const environment = await reconstructPersistedTaskEnvironment(task);
+  assertCurrent();
+  if (environment === null) {
+    throw new CredentialLeaseUnavailableError("the task's credential runtime is unavailable");
+  }
+  // Keep the exact running assignment and cancellation at each provider's
+  // last exec boundary too: reconstruction or address lookup can suspend
+  // while Stop or a new run replaces the runtime.
+  const writable: TaskWriteEnvironment = {
+    descriptor: environment.descriptor,
+    exec: (request) => {
+      assertCurrent();
+      return environment.exec({
+        ...request,
+        admit: () => {
+          assertCurrent();
+          request.admit?.();
+        },
+      });
+    },
+  };
+  await writeTaskPersonCredentials(writable, assignment, lanes, signal);
+  assertCurrent();
+}

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;
+}