@vimhead.dev/norn-cli 0.1.0-tip.0

package/dist/internal/engine.js

@@ -0,0 +1,399 @@
+// src/internal/engine.ts
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { initializeRunResources } from "./run-resources.js";
+import { createRunFileCoordinator } from "@vimhead.dev/norn/files";
+import { NornAgentResponseCollector } from "./agent-response-tool.js";
+import { NornArtifacts } from "./artifacts.js";
+import { errorMessage, NornRunStoppedError } from "./errors.js";
+import { NornRunLogs } from "./logs.js";
+import { clearRunResumeRequest, matchesRunResumeRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.js";
+import { NornRunLease } from "./run-lease.js";
+import { NornRunLogger } from "./run-log.js";
+import { NornRunStore, runCurrentRoot } from "./run-store.js";
+import { NornRunStateStore, getRunInfo, mergeInterruptedWorkflowParams, resolveRunRoot } from "./run-state.js";
+import { NornRunContext } from "./run.js";
+import { NornMemoryWorkflowState } from "./state-store.js";
+import { NornWorkflowRegistry } from "./workflow-registry.js";
+var RUNS_DIR_NAME = ".norn";
+var MANIFEST_FILE_NAME = "manifest.json";
+var NornEngine = class {
+  constructor(input) {
+    this.input = input;
+    this.responseCollector = input.responseCollector ?? new NornAgentResponseCollector();
+  }
+  input;
+  registry = new NornWorkflowRegistry();
+  registrarState = new NornMemoryWorkflowState();
+  disposersByPlugin = /* @__PURE__ */ new Map();
+  responseCollector;
+  activeRuns = /* @__PURE__ */ new Map();
+  registerPlugin(plugin) {
+    this.disposePlugin(plugin.manifest.id);
+    const implementation = this.resolvePluginImplementation(plugin.implementation);
+    const disposers = Object.entries(plugin.manifest.workflows).map(([key, workflow]) => {
+      const workflowImplementation = implementation.workflows[key];
+      if (!workflowImplementation) throw new Error(`Missing implementation for workflow ${plugin.manifest.id}.${key}`);
+      return this.registry.register(workflow, workflowImplementation, { plugin: { id: plugin.manifest.id }, configSchema: plugin.manifest.config, config: this.input.config?.[plugin.manifest.id] });
+    });
+    this.disposersByPlugin.set(plugin.manifest.id, disposers);
+    return () => {
+      if (this.disposersByPlugin.get(plugin.manifest.id) === disposers) this.disposePlugin(plugin.manifest.id);
+    };
+  }
+  listWorkflows() {
+    return this.registry.list();
+  }
+  visibleWorkflowEntries() {
+    return this.registry.launchableEntries();
+  }
+  resolvePluginImplementation(implementationInput) {
+    return typeof implementationInput === "function" ? implementationInput({ cwd: this.input.cwd, state: this.registrarState }) : implementationInput;
+  }
+  async runWorkflow(workflow, params, options) {
+    const session = await this.createRunSession(workflow, params, options);
+    const current = session.state.currentState().current;
+    if (!current) throw new Error("New run is missing its initial workflow step");
+    return this.runScheduler(session, toWorkflowStep(workflow, current));
+  }
+  async listRunCheckpoints(path) {
+    const runRoot = await resolveRunRoot(this.input.cwd, path);
+    return (await NornRunStore.open(runRoot)).listCheckpoints();
+  }
+  async rollbackRun(path, checkpointId) {
+    const runRoot = await resolveRunRoot(this.input.cwd, path);
+    const lease = await NornRunLease.acquire(runRoot);
+    try {
+      const pendingRequest = await readOptionalRunResumeRequest(runRoot);
+      if (pendingRequest && Date.now() - Date.parse(pendingRequest.createdAt) < RESUME_START_GRACE_MS) throw new Error(`Resume request is still pending: ${runRoot}`);
+      const runStore = await NornRunStore.open(runRoot);
+      await runStore.restoreSnapshot(checkpointId, async (stagedRunRoot) => {
+        const state = await NornRunStateStore.load(stagedRunRoot);
+        await state.prepareForResumeAfterRollback();
+      });
+      if (pendingRequest) await clearRunResumeRequest({ runRoot, request: pendingRequest, lease });
+      return getRunInfo(runRoot);
+    } finally {
+      await lease.release();
+    }
+  }
+  async resumeWorkflow(path, params) {
+    return this.resumeWorkflowExecution({ path, params, expectedRequest: void 0 });
+  }
+  async resumeRequestedWorkflow(input) {
+    return this.resumeWorkflowExecution({ path: input.runRoot, params: input.request.params, expectedRequest: input.request });
+  }
+  async resumeWorkflowExecution(input) {
+    const { params, expectedRequest } = input;
+    const runRoot = await resolveRunRoot(this.input.cwd, input.path);
+    const initialStateStore = await NornRunStateStore.load(runRoot);
+    const initialState = initialStateStore.currentState();
+    if (initialState.status === "interrupted" && params === void 0) throw new Error(`Interrupted workflow resume requires params: ${runRoot}`);
+    if (initialState.status === "pendingResume" && params !== void 0) throw new Error(`Pending-resume workflows do not accept params: ${runRoot}`);
+    if (initialState.status !== "interrupted" && initialState.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
+    const lease = await NornRunLease.acquire(runRoot);
+    let isLeaseOwnedByScheduler = false;
+    let session;
+    try {
+      const pendingRequest = await readOptionalRunResumeRequest(runRoot);
+      if (expectedRequest ? !matchesRunResumeRequest(pendingRequest, expectedRequest) : pendingRequest !== void 0) throw new Error(`Resume request changed or belongs to another executor: ${runRoot}`);
+      session = await this.openRunSession(runRoot, lease);
+      const state = session.state.currentState();
+      const current = state.current;
+      if (!current) throw new Error(`Run is not resumable: ${runRoot}`);
+      const workflow = this.registry.workflowById(current.workflowId);
+      if (!workflow) throw new Error(`Unknown workflow for resumed run: ${current.workflowId}`);
+      if (state.status === "interrupted") {
+        const parsedParams = workflow.params.parse(mergeInterruptedWorkflowParams(current.params, params, current.interruption?.fields));
+        await session.state.replaceCurrentParams(parsedParams);
+        await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+        const resumedCurrent = session.state.currentState().current;
+        if (!resumedCurrent) throw new Error(`Run is not resumable: ${runRoot}`);
+        isLeaseOwnedByScheduler = true;
+        return this.runScheduler(session, toWorkflowStep(workflow, resumedCurrent));
+      }
+      if (state.status !== "pendingResume") throw new Error(`Run must be rolled back before resuming: ${runRoot}`);
+      await recordRunEvent(session, { type: "run.resumed", workflowId: workflow.id, cwd: session.run.cwd });
+      isLeaseOwnedByScheduler = true;
+      return this.runScheduler(session, toWorkflowStep(workflow, current));
+    } finally {
+      if (!isLeaseOwnedByScheduler) {
+        try {
+          await lease.release();
+        } finally {
+          if (session) this.failActiveRun(runRoot, session.activeRun);
+        }
+      }
+    }
+  }
+  async runScheduler(session, initialStep) {
+    let currentStep = initialStep;
+    try {
+      for (let step = 1; step <= 1e3; step++) {
+        throwIfRunAborted(session.activeRun);
+        const stepRuntime = session.run.forWorkflow(currentStep.workflow);
+        if (shouldPauseForGate(currentStep)) {
+          const parsedParams = currentStep.workflow.params.parse(currentStep.params);
+          const description = await this.registry.describeGate(currentStep.workflow, stepRuntime, parsedParams, session.state.currentState().configOverride);
+          const interruption = { description, fields: currentStep.workflow.gate?.fields };
+          await session.state.interruptCurrent(parsedParams, interruption);
+          await recordRunEvent(session, { type: "run.interrupted", workflowId: currentStep.workflow.id });
+          await commitRunBoundary(session, `run interrupted: ${currentStep.workflow.id}`);
+          return interruptedLaunchResult({ id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd }, currentStep.workflow, parsedParams, interruption);
+        }
+        await session.state.startStep(toRunStateStep(currentStep));
+        const stepResult = await this.executeWorkflowStep(session, currentStep, stepRuntime);
+        throwIfRunAborted(session.activeRun);
+        if (stepResult.type === "complete") {
+          await session.state.completeRun(stepResult.workflow.id, stepResult.metadata);
+          await recordRunEvent(session, { type: "run.completed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
+          await commitRunBoundary(session, `run completed: ${stepResult.workflow.id}`);
+          return { status: "completed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+        }
+        if (stepResult.type === "fail") {
+          await session.state.failRun(stepResult.workflow.id, stepResult.metadata);
+          await recordRunEvent(session, { type: "run.failed", workflowId: stepResult.workflow.id, metadata: stepResult.metadata });
+          return { status: "failed", id: stepRuntime.id, name: session.state.currentState().name, workspace: stepRuntime.workspace, cwd: stepRuntime.cwd, workflowId: stepResult.workflow.id, metadata: stepResult.metadata };
+        }
+        const nextStep = this.nextWorkflowStep(stepResult);
+        await session.state.completeWithNext(currentStep.workflow.id, toRunStateStep(nextStep));
+        await recordRunEvent(session, { type: "run.transitioned", fromWorkflowId: currentStep.workflow.id, toWorkflowId: nextStep.workflow.id });
+        await commitRunBoundary(session, `transition: ${currentStep.workflow.id} -> ${nextStep.workflow.id}`);
+        currentStep = nextStep;
+      }
+      throw new Error("Run exceeded 1000 scheduler steps");
+    } catch (error) {
+      if (isRunStopped(session, error)) {
+        await session.state.stopCurrent();
+        await recordRunEvent(session, { type: "run.stopped", workflowId: currentStep.workflow.id });
+        return { status: "stopped", id: session.run.id, name: session.state.currentState().name, workspace: session.run.workspace, cwd: session.run.cwd, workflowId: currentStep.workflow.id };
+      }
+      await session.state.failCurrent(errorMessage(error));
+      await recordRunEvent(session, { type: "run.failed", workflowId: currentStep.workflow.id, error: errorMessage(error) });
+      throw error;
+    } finally {
+      await session.lease.release();
+      this.finishActiveRun(session.runRoot, session.activeRun);
+    }
+  }
+  async executeWorkflowStep(session, step, run) {
+    const startedAtMs = Date.now();
+    try {
+      await assertWorkspaceBoundary(session, run.workspace);
+      await recordRunEvent(session, { type: "workflow.started", workflowId: step.workflow.id });
+      const result = await this.registry.execute(step.workflow, run, step.params, session.state.currentState().configOverride);
+      await assertWorkspaceBoundary(session, run.workspace);
+      const durationMs = Date.now() - startedAtMs;
+      if (result.type === "complete") await recordRunEvent(session, { type: "workflow.completed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
+      else if (result.type === "fail") await recordRunEvent(session, { type: "workflow.failed", workflowId: result.workflow.id, durationMs, metadata: result.metadata });
+      else await recordRunEvent(session, { type: "workflow.transitioned", fromWorkflowId: step.workflow.id, toWorkflowId: result.workflowId, durationMs });
+      return result;
+    } catch (error) {
+      await recordRunEvent(session, {
+        type: isRunStopped(session, error) ? "workflow.stopped" : "workflow.failed",
+        workflowId: step.workflow.id,
+        durationMs: Date.now() - startedAtMs,
+        ...isRunStopped(session, error) ? {} : { error: errorMessage(error) }
+      });
+      throw error;
+    }
+  }
+  nextWorkflowStep(next) {
+    const workflow = this.registry.workflowById(next.workflowId);
+    if (!workflow) throw new Error(`Unknown next workflow: ${next.workflowId}`);
+    return {
+      workflow,
+      params: next.params,
+      interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
+    };
+  }
+  async createRunSession(workflow, params, options) {
+    const id = options?.id ?? randomUUID();
+    const name = options?.name ?? id;
+    const runRoot = defaultRunRoot(this.input.cwd, id);
+    const currentRoot = runCurrentRoot(runRoot);
+    const workspace = join(currentRoot, "workspace");
+    const cwd = workflowDefaultCwd(this.input.cwd, workspace, workflow);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await mkdir(runRoot, { recursive: true });
+    const lease = await NornRunLease.acquire(runRoot);
+    const activeRun = this.startActiveRun(runRoot);
+    try {
+      const runStore = await NornRunStore.initialize(runRoot);
+      await mkdir(workspace, { recursive: true });
+      const logger = new NornRunLogger({ manifestPath: join(currentRoot, MANIFEST_FILE_NAME), files: createRunFileCoordinator(runRoot), manifest: {
+        id,
+        name,
+        workflowId: workflow.id,
+        runRoot,
+        workspace,
+        initialCwd: cwd,
+        startedAt
+      } });
+      const run = await this.buildRun({ id, currentRoot, workspace, cwd, isolationMode: workflow.isolation.mode, signal: activeRun.controller.signal, logger });
+      const state = await NornRunStateStore.create(runRoot, {
+        id,
+        name,
+        entrypointWorkflowId: workflow.id,
+        workspace,
+        configOverride: options?.configOverride,
+        current: {
+          workflowId: workflow.id,
+          params,
+          cwd,
+          env: {},
+          interruption: this.input.gateMode === "pause" && workflow.gate ? { status: "pending" } : void 0
+        },
+        startedAt
+      });
+      const session = { runRoot, run, state, lease, runStore, logger, activeRun };
+      await logger.record({ type: "run.started", workflowId: workflow.id, cwd, workspace });
+      await commitRunBoundary(session, `run started: ${workflow.id}`);
+      return session;
+    } catch (error) {
+      await lease.release();
+      this.failActiveRun(runRoot, activeRun);
+      throw error;
+    }
+  }
+  async openRunSession(runRoot, lease) {
+    const activeRun = this.startActiveRun(runRoot);
+    try {
+      const state = await NornRunStateStore.load(runRoot);
+      const currentState = state.currentState();
+      if (currentState.status === "completed") throw new Error(`Run is already completed: ${runRoot}`);
+      const runStore = await NornRunStore.open(runRoot);
+      const currentRoot = runCurrentRoot(runRoot);
+      const logger = await NornRunLogger.load(join(currentRoot, MANIFEST_FILE_NAME), createRunFileCoordinator(runRoot));
+      const workflow = currentState.current ? this.registry.workflowById(currentState.current.workflowId) : void 0;
+      const isolationMode = workflow?.isolation.mode ?? "runWorkspace";
+      const cwd = workflowDefaultCwd(this.input.cwd, currentState.workspace, workflow);
+      const run = await this.buildRun({ id: currentState.id, currentRoot, workspace: currentState.workspace, cwd, isolationMode, signal: activeRun.controller.signal, logger });
+      return { runRoot, run, state, lease, runStore, logger, activeRun };
+    } catch (error) {
+      this.failActiveRun(runRoot, activeRun);
+      throw error;
+    }
+  }
+  async buildRun(input) {
+    const artifactsRoot = join(input.currentRoot, "artifacts");
+    const logsRoot = join(input.currentRoot, "logs");
+    await mkdir(input.workspace, { recursive: true });
+    await mkdir(artifactsRoot, { recursive: true });
+    await mkdir(logsRoot, { recursive: true });
+    const { resources, state } = await initializeRunResources(dirname(input.currentRoot));
+    return new NornRunContext({
+      id: input.id,
+      runRoot: input.currentRoot,
+      workspace: input.workspace,
+      projectRoot: this.input.cwd,
+      cwd: input.cwd,
+      isolationMode: input.isolationMode,
+      signal: input.signal,
+      agentDir: this.input.agentDir,
+      responseCollector: this.responseCollector,
+      resources,
+      state,
+      logger: input.logger,
+      artifacts: new NornArtifacts(artifactsRoot, resources.files),
+      logs: new NornRunLogs(logsRoot, resources.files)
+    });
+  }
+  startActiveRun(runRoot) {
+    if (this.activeRuns.has(runRoot)) throw new Error(`Run is already active in this engine: ${runRoot}`);
+    const controller = new AbortController();
+    let finish;
+    const finished = new Promise((resolvePromise) => {
+      finish = resolvePromise;
+    });
+    const abortFromParent = () => controller.abort(this.input.signal?.reason);
+    if (this.input.signal?.aborted) abortFromParent();
+    else this.input.signal?.addEventListener("abort", abortFromParent, { once: true });
+    const activeRun = {
+      controller,
+      finished,
+      finish: () => finish(),
+      dispose: () => this.input.signal?.removeEventListener("abort", abortFromParent)
+    };
+    this.activeRuns.set(runRoot, activeRun);
+    return activeRun;
+  }
+  finishActiveRun(runRoot, activeRun) {
+    if (this.activeRuns.get(runRoot) !== activeRun) return;
+    this.activeRuns.delete(runRoot);
+    activeRun.dispose();
+    activeRun.finish();
+  }
+  failActiveRun(runRoot, activeRun) {
+    if (this.activeRuns.get(runRoot) === activeRun) this.activeRuns.delete(runRoot);
+    activeRun.dispose();
+    activeRun.finish();
+  }
+  disposePlugin(pluginId) {
+    const disposers = this.disposersByPlugin.get(pluginId) ?? [];
+    for (const dispose of [...disposers].reverse()) dispose();
+    this.disposersByPlugin.delete(pluginId);
+  }
+};
+function defaultRunRoot(cwd, id) {
+  return join(cwd, RUNS_DIR_NAME, "runs", id);
+}
+function workflowDefaultCwd(projectRoot, workspace, workflow) {
+  return workflow?.isolation.mode === "project" ? projectRoot : workspace;
+}
+function toWorkflowStep(workflow, step) {
+  return {
+    workflow,
+    params: step.params,
+    interruption: step.interruption
+  };
+}
+function toRunStateStep(step) {
+  return {
+    workflowId: step.workflow.id,
+    params: step.params,
+    cwd: "",
+    env: {},
+    interruption: step.interruption
+  };
+}
+function shouldPauseForGate(step) {
+  return step.interruption?.status === "pending" && step.workflow.gate !== void 0;
+}
+function throwIfRunAborted(activeRun) {
+  if (!activeRun.controller.signal.aborted) return;
+  const reason = activeRun.controller.signal.reason;
+  if (reason instanceof Error) throw reason;
+  throw new Error(typeof reason === "string" && reason.length > 0 ? reason : "Run aborted");
+}
+function isRunStopped(session, error) {
+  return error instanceof NornRunStoppedError || session.activeRun.controller.signal.reason instanceof NornRunStoppedError;
+}
+function interruptedLaunchResult(run, workflow, params, interruption) {
+  if (!workflow.gate) throw new Error(`Workflow is not gated: ${workflow.id}`);
+  if (!interruption.description) throw new Error(`Interrupted workflow is missing description: ${workflow.id}`);
+  return {
+    status: "interrupted",
+    id: run.id,
+    name: run.name,
+    workspace: run.workspace,
+    cwd: run.cwd,
+    workflowId: workflow.id,
+    interruption: { workflowId: workflow.id, params, description: interruption.description, fields: interruption.fields }
+  };
+}
+async function recordRunEvent(session, event) {
+  await session.logger.record(event);
+}
+async function commitRunBoundary(session, message) {
+  await session.lease.assertOwned();
+  await session.runStore.snapshotCurrent(message);
+}
+async function assertWorkspaceBoundary(session, workspace) {
+  await session.lease.assertOwned();
+  await session.runStore.assertWorkspaceCanBeSnapshotted(workspace);
+}
+export {
+  NornEngine
+};

package/dist/internal/errors.d.ts

@@ -0,0 +1,14 @@
+import type { NornPluginDiagnostic } from "@vimhead.dev/norn";
+export declare class NornProjectLoadError extends Error {
+    readonly code = "NORN_PROJECT_INVALID";
+    readonly isComplete = false;
+    readonly diagnostics: readonly NornPluginDiagnostic[];
+    constructor(input: {
+        readonly diagnostics: readonly NornPluginDiagnostic[];
+    });
+}
+export declare class NornRunStoppedError extends Error {
+    constructor();
+}
+export declare function zodErrorMessage(error: unknown): string;
+export declare function errorMessage(error: unknown): string;

package/dist/internal/errors.js

@@ -0,0 +1,38 @@
+// src/internal/errors.ts
+var NornProjectLoadError = class extends Error {
+  code = "NORN_PROJECT_INVALID";
+  isComplete = false;
+  diagnostics;
+  constructor(input) {
+    const details = input.diagnostics.map(
+      (diagnostic) => `${diagnostic.stage}: ${diagnostic.pluginPath} (declared in ${diagnostic.configPath}${diagnostic.workflowId ? `; workflow ${diagnostic.workflowId}` : ""}): ${diagnostic.message}`
+    );
+    super(`Norn project is incomplete (${input.diagnostics.length} diagnostics); execution is blocked.
+${details.join("\n")}`);
+    this.name = "NornProjectLoadError";
+    this.diagnostics = input.diagnostics;
+  }
+};
+var NornRunStoppedError = class extends Error {
+  constructor() {
+    super("Stopped by user");
+    this.name = "NornRunStoppedError";
+  }
+};
+function zodErrorMessage(error) {
+  const issues = error.issues;
+  if (!Array.isArray(issues) || issues.length === 0) return errorMessage(error);
+  return issues.slice(0, 3).map((issue) => {
+    const path = Array.isArray(issue.path) && issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
+    return `${path}${issue.message ?? "Invalid workflow response"}`;
+  }).join("; ");
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  NornProjectLoadError,
+  NornRunStoppedError,
+  errorMessage,
+  zodErrorMessage
+};

package/dist/internal/file-names.d.ts

@@ -0,0 +1 @@
+export declare function safeFileName(value: string): string;

package/dist/internal/file-names.js

@@ -0,0 +1,7 @@
+// src/internal/file-names.ts
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow";
+}
+export {
+  safeFileName
+};

package/dist/internal/launch-request.d.ts

@@ -0,0 +1,33 @@
+import type { NornRunLease } from "./run-lease.ts";
+export declare const LAUNCH_REQUEST_FILE_NAME = "launch-request.json";
+export declare const RESUME_REQUEST_FILE_NAME = "resume-request.json";
+export declare const RESUME_START_GRACE_MS = 60000;
+export type NornRunLaunchRequest = {
+    readonly version: 1;
+    readonly type: "run";
+    readonly id: string;
+    readonly name: string;
+    readonly workflowId: string;
+    readonly params: unknown;
+    readonly configOverride?: unknown;
+    readonly createdAt: string;
+};
+export type NornRunResumeRequest = {
+    readonly version: 1;
+    readonly type: "resume";
+    readonly id: string;
+    readonly requestId?: string;
+    readonly params?: unknown;
+    readonly createdAt: string;
+};
+export declare function writeRunLaunchRequest(runRoot: string, request: NornRunLaunchRequest): Promise<void>;
+export declare function readRunLaunchRequest(runRoot: string): Promise<NornRunLaunchRequest>;
+export declare function writeRunResumeRequest(runRoot: string, request: NornRunResumeRequest): Promise<void>;
+export declare function readRunResumeRequest(runRoot: string): Promise<NornRunResumeRequest>;
+export declare function readOptionalRunResumeRequest(runRoot: string): Promise<NornRunResumeRequest | undefined>;
+export declare function matchesRunResumeRequest(actual: NornRunResumeRequest | undefined, expected: NornRunResumeRequest): boolean;
+export declare function clearRunResumeRequest(input: {
+    readonly runRoot: string;
+    readonly request: NornRunResumeRequest;
+    readonly lease: NornRunLease;
+}): Promise<void>;

package/dist/internal/launch-request.js

@@ -0,0 +1,110 @@
+// src/internal/launch-request.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { link, readFile, rm as rm2 } from "node:fs/promises";
+import { join } from "node:path";
+
+// ../core/src/atomic-files.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// ../core/src/atomic-files.ts
+async function writeJsonAtomically(path, value) {
+  await writeTextAtomically(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function writeTextAtomically(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  let existingMode;
+  try {
+    existingMode = (await stat(path)).mode & 511;
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+  }
+  const tmpPath = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmpPath, content, { encoding: "utf8", mode: existingMode });
+    if (existingMode !== void 0) await chmod(tmpPath, existingMode);
+    await rename(tmpPath, path);
+  } catch (error) {
+    await rm(tmpPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/internal/launch-request.ts
+var LAUNCH_REQUEST_FILE_NAME = "launch-request.json";
+var RESUME_REQUEST_FILE_NAME = "resume-request.json";
+var RESUME_START_GRACE_MS = 6e4;
+async function writeRunLaunchRequest(runRoot, request) {
+  await writeJsonAtomically(join(runRoot, LAUNCH_REQUEST_FILE_NAME), request);
+}
+async function readRunLaunchRequest(runRoot) {
+  return parseRunLaunchRequest(JSON.parse(await readFile(join(runRoot, LAUNCH_REQUEST_FILE_NAME), "utf8")));
+}
+async function writeRunResumeRequest(runRoot, request) {
+  const path = join(runRoot, RESUME_REQUEST_FILE_NAME);
+  const stagedPath = `${path}.${randomUUID2()}.tmp`;
+  try {
+    await writeJsonAtomically(stagedPath, request);
+    await link(stagedPath, path);
+  } finally {
+    await rm2(stagedPath, { force: true }).catch(() => void 0);
+  }
+}
+async function readRunResumeRequest(runRoot) {
+  return parseRunResumeRequest(JSON.parse(await readFile(join(runRoot, RESUME_REQUEST_FILE_NAME), "utf8")));
+}
+async function readOptionalRunResumeRequest(runRoot) {
+  try {
+    return await readRunResumeRequest(runRoot);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function matchesRunResumeRequest(actual, expected) {
+  return actual?.id === expected.id && (actual.requestId ?? actual.createdAt) === (expected.requestId ?? expected.createdAt);
+}
+async function clearRunResumeRequest(input) {
+  await input.lease.assertOwned();
+  if (matchesRunResumeRequest(await readOptionalRunResumeRequest(input.runRoot), input.request)) {
+    await rm2(join(input.runRoot, RESUME_REQUEST_FILE_NAME), { force: true });
+  }
+}
+function parseRunLaunchRequest(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid workflow launch request");
+  const request = value;
+  if (request.version !== 1 || request.type !== "run") throw new Error("Unsupported workflow launch request");
+  if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow launch request id");
+  if (typeof request.name !== "string" || request.name.length === 0) throw new Error("Invalid workflow launch request name");
+  if (typeof request.workflowId !== "string" || request.workflowId.length === 0) throw new Error("Invalid workflow launch request workflow id");
+  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow launch request timestamp");
+  return request;
+}
+function parseRunResumeRequest(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid workflow resume request");
+  const request = value;
+  if (request.version !== 1 || request.type !== "resume") throw new Error("Unsupported workflow resume request");
+  if (typeof request.id !== "string" || request.id.length === 0) throw new Error("Invalid workflow resume request id");
+  if (request.requestId !== void 0 && (typeof request.requestId !== "string" || request.requestId.length === 0)) throw new Error("Invalid workflow resume request token");
+  if (typeof request.createdAt !== "string" || Number.isNaN(Date.parse(request.createdAt))) throw new Error("Invalid workflow resume request timestamp");
+  return request;
+}
+export {
+  LAUNCH_REQUEST_FILE_NAME,
+  RESUME_REQUEST_FILE_NAME,
+  RESUME_START_GRACE_MS,
+  clearRunResumeRequest,
+  matchesRunResumeRequest,
+  readOptionalRunResumeRequest,
+  readRunLaunchRequest,
+  readRunResumeRequest,
+  writeRunLaunchRequest,
+  writeRunResumeRequest
+};

package/dist/internal/logs.d.ts

@@ -0,0 +1,16 @@
+import { type WriteStream } from "node:fs";
+import type { NornFileCoordinator } from "@vimhead.dev/norn/files";
+import type { NornLogRef } from "@vimhead.dev/norn";
+export type NornLogWriteStream = {
+    readonly log: NornLogRef;
+    readonly stream: WriteStream;
+};
+export declare class NornRunLogs {
+    private readonly logsRoot;
+    private readonly files;
+    constructor(logsRoot: string, files: NornFileCoordinator);
+    write(path: string, content: string): Promise<void>;
+    read(log: NornLogRef): Promise<string>;
+    createWriteStream(log: NornLogRef): Promise<NornLogWriteStream>;
+    private resolveLogPath;
+}

package/dist/internal/logs.js

@@ -0,0 +1,38 @@
+// src/internal/logs.ts
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+var NornRunLogs = class {
+  constructor(logsRoot, files) {
+    this.logsRoot = logsRoot;
+    this.files = files;
+  }
+  logsRoot;
+  files;
+  async write(path, content) {
+    await this.files.writeText(this.resolveLogPath(path), content);
+  }
+  async read(log) {
+    return this.files.readText(this.resolveLogPath(`${log.id}.log`));
+  }
+  async createWriteStream(log) {
+    const absolutePath = this.resolveLogPath(`${log.id}.log`);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    return {
+      log,
+      stream: createWriteStream(absolutePath, { encoding: "utf8" })
+    };
+  }
+  resolveLogPath(path) {
+    if (isAbsolute(path)) throw new Error(`Log path must be relative: ${path}`);
+    const resolvedPath = resolve(this.logsRoot, path);
+    const relativePath = relative(this.logsRoot, resolvedPath);
+    if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+      throw new Error(`Log path escapes logs directory: ${path}`);
+    }
+    return resolvedPath;
+  }
+};
+export {
+  NornRunLogs
+};