@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/dist/internal/run-lease.js

@@ -80,7 +80,8 @@ var NornRunLease = class _NornRunLease {
   async assertOwned() {
     if (this.isReleased) throw new Error("Run lease has been released");
     const owner = await readRunLeaseOwner(this.ownerPath);
-    if (!owner || owner.token !== this.token) throw new Error("Run lease was lost");
+    if (!owner || owner.token !== this.token)
+      throw new Error("Run lease was lost");
   }
   async release() {
     if (this.isReleased) return;
@@ -88,7 +89,8 @@ var NornRunLease = class _NornRunLease {
     if (this.heartbeat) clearInterval(this.heartbeat);
     await this.heartbeatChain.catch(() => void 0);
     const owner = await readRunLeaseOwner(this.ownerPath);
-    if (owner?.token === this.token) await rm2(this.lockRoot, { recursive: true, force: true });
+    if (owner?.token === this.token)
+      await rm2(this.lockRoot, { recursive: true, force: true });
   }
   get ownerPath() {
     return join(this.lockRoot, OWNER_FILE_NAME);
@@ -105,12 +107,18 @@ var NornRunLease = class _NornRunLease {
   async refreshHeartbeat() {
     if (this.isReleased) return;
     const owner = await readRunLeaseOwner(this.ownerPath);
-    if (!owner || owner.token !== this.token) throw new Error("Run lease was lost");
+    if (!owner || owner.token !== this.token)
+      throw new Error("Run lease was lost");
     await this.writeOwner({ acquiredAt: owner.acquiredAt });
   }
   async writeOwner(input) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    await writeJsonAtomically(this.ownerPath, { token: this.token, acquiredAt: input.acquiredAt, heartbeatAt: now, ...this.processOwner });
+    await writeJsonAtomically(this.ownerPath, {
+      token: this.token,
+      acquiredAt: input.acquiredAt,
+      heartbeatAt: now,
+      ...this.processOwner
+    });
   }
 };
 async function getRunLeaseHealth(runRoot) {
@@ -140,13 +148,25 @@ async function readRunLeaseOwner(path) {
 function parseRunLeaseOwner(value) {
   if (!value || typeof value !== "object") return void 0;
   const owner = value;
-  if (typeof owner.token !== "string" || owner.token.length === 0) return void 0;
-  if (typeof owner.acquiredAt !== "string" || Number.isNaN(Date.parse(owner.acquiredAt))) return void 0;
-  if (typeof owner.heartbeatAt !== "string" || Number.isNaN(Date.parse(owner.heartbeatAt))) return void 0;
+  if (typeof owner.token !== "string" || owner.token.length === 0)
+    return void 0;
+  if (typeof owner.acquiredAt !== "string" || Number.isNaN(Date.parse(owner.acquiredAt)))
+    return void 0;
+  if (typeof owner.heartbeatAt !== "string" || Number.isNaN(Date.parse(owner.heartbeatAt)))
+    return void 0;
   const pid = typeof owner.pid === "number" && Number.isInteger(owner.pid) ? owner.pid : 0;
   const processGroupId = typeof owner.processGroupId === "number" && Number.isInteger(owner.processGroupId) ? owner.processGroupId : pid;
-  const command = Array.isArray(owner.command) ? owner.command.filter((value2) => typeof value2 === "string") : [];
-  return { token: owner.token, acquiredAt: owner.acquiredAt, heartbeatAt: owner.heartbeatAt, pid, processGroupId, command };
+  const command = Array.isArray(owner.command) ? owner.command.filter(
+    (value2) => typeof value2 === "string"
+  ) : [];
+  return {
+    token: owner.token,
+    acquiredAt: owner.acquiredAt,
+    heartbeatAt: owner.heartbeatAt,
+    pid,
+    processGroupId,
+    command
+  };
 }
 function isRunLeaseStale(owner) {
   return Date.now() - Date.parse(owner.heartbeatAt) > HEARTBEAT_TTL_MS;

package/dist/internal/run-log.js

@@ -47,23 +47,35 @@ var NornRunLogger = class _NornRunLogger {
     return logger;
   }
   async record(event) {
-    await this.input.files.withExclusiveLock(this.input.manifestPath, async (path) => {
-      let manifest;
-      try {
-        manifest = parseManifest(await readFile(path, "utf8"));
-      } catch (error) {
-        if (this.isInitialized || !isNodeError(error) || error.code !== "ENOENT") throw error;
-        manifest = { ...this.input.manifest, events: [] };
+    await this.input.files.withExclusiveLock(
+      this.input.manifestPath,
+      async (path) => {
+        let manifest;
+        try {
+          manifest = parseManifest(await readFile(path, "utf8"));
+        } catch (error) {
+          if (this.isInitialized || !isNodeError(error) || error.code !== "ENOENT")
+            throw error;
+          manifest = { ...this.input.manifest, events: [] };
+        }
+        if (manifest.id !== this.input.manifest.id)
+          throw new Error("Run manifest identity changed");
+        await writeJsonAtomically(path, {
+          ...manifest,
+          events: [
+            ...manifest.events,
+            { ...event, at: (/* @__PURE__ */ new Date()).toISOString() }
+          ]
+        });
+        this.isInitialized = true;
       }
-      if (manifest.id !== this.input.manifest.id) throw new Error("Run manifest identity changed");
-      await writeJsonAtomically(path, { ...manifest, events: [...manifest.events, { ...event, at: (/* @__PURE__ */ new Date()).toISOString() }] });
-      this.isInitialized = true;
-    });
+    );
   }
 };
 function parseManifest(content) {
   const manifest = JSON.parse(content);
-  if (!manifest || typeof manifest !== "object" || typeof manifest.id !== "string" || !Array.isArray(manifest.events)) throw new Error("Invalid run manifest");
+  if (!manifest || typeof manifest !== "object" || typeof manifest.id !== "string" || !Array.isArray(manifest.events))
+    throw new Error("Invalid run manifest");
   return manifest;
 }
 export {

package/dist/internal/run-state.js

@@ -8,7 +8,11 @@ function isNodeError(error) {
 }
 
 // src/internal/run-state.ts
-import { readRunLaunchRequest, readOptionalRunResumeRequest, RESUME_START_GRACE_MS } from "./launch-request.js";
+import {
+  readRunLaunchRequest,
+  readOptionalRunResumeRequest,
+  RESUME_START_GRACE_MS
+} from "./launch-request.js";
 import { getRunLeaseHealth } from "./run-lease.js";
 
 // ../core/src/atomic-files.ts
@@ -39,7 +43,9 @@ async function writeTextAtomically(path, content) {
 }
 
 // src/internal/run-state.ts
-import { createRunFileCoordinator } from "./file-coordinator.js";
+import {
+  createRunFileCoordinator
+} from "./file-coordinator.js";
 import { runCurrentRoot } from "./run-store.js";
 import { jsonValueSchema } from "@vimhead.dev/norn/schema";
 import { Value } from "typebox/value";
@@ -48,8 +54,13 @@ var LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
 function mergeInterruptedWorkflowArgs(currentArgs, args, fields) {
   if (!isRecord(currentArgs) || !isRecord(args)) return args;
   if (fields) {
-    const unsupportedFields = Object.keys(args).filter((field) => !fields.includes(field));
-    if (unsupportedFields.length > 0) throw new Error(`Interrupted workflow args cannot update non-gate fields: ${unsupportedFields.join(", ")}`);
+    const unsupportedFields = Object.keys(args).filter(
+      (field) => !fields.includes(field)
+    );
+    if (unsupportedFields.length > 0)
+      throw new Error(
+        `Interrupted workflow args cannot update non-gate fields: ${unsupportedFields.join(", ")}`
+      );
   }
   return { ...currentArgs, ...args };
 }
@@ -81,27 +92,53 @@ var NornRunStateStore = class _NornRunStateStore {
       startedAt: now,
       updatedAt: now
     };
-    const store = new _NornRunStateStore({ path: join(runCurrentRoot(runRoot), RUN_STATE_FILE_NAME), state, files: createRunFileCoordinator(runRoot) });
+    const store = new _NornRunStateStore({
+      path: join(runCurrentRoot(runRoot), RUN_STATE_FILE_NAME),
+      state,
+      files: createRunFileCoordinator(runRoot)
+    });
     await store.write();
     return store;
   }
   static async load(runRoot) {
     const currentRoot = runCurrentRoot(runRoot);
     const files = createRunFileCoordinator(runRoot);
-    const state = await files.withExclusiveLock(join(currentRoot, RUN_STATE_FILE_NAME), async (path) => parseNornRunState(await readRunStateFile({ path, legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME) }), "execute"));
-    return new _NornRunStateStore({ path: join(currentRoot, RUN_STATE_FILE_NAME), state, files });
+    const state = await files.withExclusiveLock(
+      join(currentRoot, RUN_STATE_FILE_NAME),
+      async (path) => parseNornRunState(
+        await readRunStateFile({
+          path,
+          legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME)
+        }),
+        "execute"
+      )
+    );
+    return new _NornRunStateStore({
+      path: join(currentRoot, RUN_STATE_FILE_NAME),
+      state,
+      files
+    });
   }
   currentState() {
     return this.state;
   }
   async startStep(step) {
-    await this.update({ status: "running", current: step, outcome: null, failed: null });
+    await this.update({
+      status: "running",
+      current: step,
+      outcome: null,
+      failed: null
+    });
   }
   async completeWithNext(completedWorkflowId, next) {
     await this.update({
       status: "running",
       current: next,
-      lastCompleted: { workflowId: completedWorkflowId, completedAt: (/* @__PURE__ */ new Date()).toISOString(), outcome: { type: "next", workflowId: next.workflowId } },
+      lastCompleted: {
+        workflowId: completedWorkflowId,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        outcome: { type: "next", workflowId: next.workflowId }
+      },
       outcome: null,
       failed: null
     });
@@ -121,62 +158,115 @@ var NornRunStateStore = class _NornRunStateStore {
     await this.update({
       status: "failed",
       current: null,
-      lastCompleted: { workflowId, completedAt: failedAt, outcome: { type: "fail" } },
-      outcome: { workflowId, completedAt: failedAt, status: "failed", metadata },
+      lastCompleted: {
+        workflowId,
+        completedAt: failedAt,
+        outcome: { type: "fail" }
+      },
+      outcome: {
+        workflowId,
+        completedAt: failedAt,
+        status: "failed",
+        metadata
+      },
       failed: { workflowId, error: metadata.summary, metadata, failedAt }
     });
   }
   async interruptCurrent(args, interruption) {
-    if (!this.state.current) throw new Error("Cannot interrupt run without current step");
+    if (!this.state.current)
+      throw new Error("Cannot interrupt run without current step");
     await this.update({
       status: "interrupted",
-      current: { ...this.state.current, args, interruption: { status: "pending", ...interruption } },
+      current: {
+        ...this.state.current,
+        args,
+        interruption: { status: "pending", ...interruption }
+      },
       outcome: null,
       failed: null
     });
   }
   async prepareForResumeAfterRollback() {
-    if (!this.state.current) throw new Error("Cannot resume a checkpoint without a current step");
+    if (!this.state.current)
+      throw new Error("Cannot resume a checkpoint without a current step");
     if (this.state.status === "interrupted") return;
-    if (this.state.status !== "running") throw new Error(`Cannot resume checkpoint with ${this.state.status} status`);
+    if (this.state.status !== "running")
+      throw new Error(
+        `Cannot resume checkpoint with ${this.state.status} status`
+      );
     await this.update({ status: "pendingResume", outcome: null, failed: null });
   }
   async stopCurrent() {
-    if (!this.state.current) throw new Error("Cannot stop run without current step");
+    if (!this.state.current)
+      throw new Error("Cannot stop run without current step");
     await this.update({ status: "stopped", outcome: null, failed: null });
   }
   async replaceCurrentArgs(args) {
-    if (!this.state.current) throw new Error("Cannot resume run without current step");
+    if (!this.state.current)
+      throw new Error("Cannot resume run without current step");
     await this.update({
       status: "running",
-      current: { ...this.state.current, args, interruption: { ...this.state.current.interruption, status: "satisfied" } },
+      current: {
+        ...this.state.current,
+        args,
+        interruption: {
+          ...this.state.current.interruption,
+          status: "satisfied"
+        }
+      },
       outcome: null,
       failed: null
     });
   }
   async failCurrent(errorOrMetadata) {
-    if (!this.state.current) throw new Error("Cannot fail run without current step");
+    if (!this.state.current)
+      throw new Error("Cannot fail run without current step");
     const failedAt = (/* @__PURE__ */ new Date()).toISOString();
     const metadata = typeof errorOrMetadata === "string" ? { summary: errorOrMetadata } : errorOrMetadata;
     await this.update({
       status: "failed",
-      outcome: { workflowId: this.state.current.workflowId, completedAt: failedAt, status: "failed", metadata },
-      failed: { workflowId: this.state.current.workflowId, error: metadata.summary, metadata, failedAt }
+      outcome: {
+        workflowId: this.state.current.workflowId,
+        completedAt: failedAt,
+        status: "failed",
+        metadata
+      },
+      failed: {
+        workflowId: this.state.current.workflowId,
+        error: metadata.summary,
+        metadata,
+        failedAt
+      }
     });
   }
   async update(patch) {
     await this.files.withExclusiveLock(this.path, async (path) => {
-      const current = parseNornRunState(await readRunStateFile({ path, legacyPath: join(dirname2(this.path), LEGACY_RUN_STATE_FILE_NAME) }), "execute");
-      const next = { ...current, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      if (next.current?.args !== void 0) Value.Assert(jsonValueSchema, next.current.args);
+      const current = parseNornRunState(
+        await readRunStateFile({
+          path,
+          legacyPath: join(dirname2(this.path), LEGACY_RUN_STATE_FILE_NAME)
+        }),
+        "execute"
+      );
+      const next = {
+        ...current,
+        ...patch,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (next.current?.args !== void 0)
+        Value.Assert(jsonValueSchema, next.current.args);
       await writeJsonAtomically(path, next);
       this.state = next;
     });
   }
   async write() {
-    if (this.state.current?.args !== void 0) Value.Assert(jsonValueSchema, this.state.current.args);
+    if (this.state.current?.args !== void 0)
+      Value.Assert(jsonValueSchema, this.state.current.args);
     await mkdir2(dirname2(this.path), { recursive: true });
-    await this.files.withExclusiveLock(this.path, (path) => writeJsonAtomically(path, this.state));
+    await this.files.withExclusiveLock(
+      this.path,
+      (path) => writeJsonAtomically(path, this.state)
+    );
   }
 };
 async function listRuns(sessionCwd) {
@@ -188,7 +278,9 @@ async function listRuns(sessionCwd) {
     if (isNodeError(error) && error.code === "ENOENT") return [];
     throw error;
   }
-  const runs = await Promise.all(entries.filter((entry) => entry.isDirectory()).map((entry) => readNornRunInfo(resolve(runsRoot, entry.name))));
+  const runs = await Promise.all(
+    entries.filter((entry) => entry.isDirectory()).map((entry) => readNornRunInfo(resolve(runsRoot, entry.name)))
+  );
   return runs.filter((run) => run !== void 0).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 async function getRunInfo(runRoot) {
@@ -197,15 +289,22 @@ async function getRunInfo(runRoot) {
       (request) => ({ status: "fulfilled", request }),
       (error) => ({ status: "rejected", error })
     );
-    const state = parseNornRunState(await readRunStateJson(runCurrentRoot(runRoot)), "inspect");
-    if (state.version === RUN_STATE_VERSION && pendingResume.status === "rejected") throw pendingResume.error;
+    const state = parseNornRunState(
+      await readRunStateJson(runCurrentRoot(runRoot)),
+      "inspect"
+    );
+    if (state.version === RUN_STATE_VERSION && pendingResume.status === "rejected")
+      throw pendingResume.error;
     const resumeRequest = state.version === RUN_STATE_VERSION && pendingResume.status === "fulfilled" ? pendingResume.request : void 0;
     return {
       version: state.version,
       id: state.id,
       name: state.name,
       path: runRoot,
-      paths: { project: state.projectRoot ?? resolve(runRoot, "../../.."), workspace: state.workspace },
+      paths: {
+        project: state.projectRoot ?? resolve(runRoot, "../../.."),
+        workspace: state.workspace
+      },
       entrypointWorkflowId: state.entrypointWorkflowId,
       currentWorkflowId: state.current?.workflowId,
       status: resumeRequest ? "running" : state.status,
@@ -226,17 +325,21 @@ async function resolveRunRoot(sessionCwd, run) {
     try {
       if (await readNornRunInfo(candidate)) return candidate;
     } catch (error) {
-      if (!isNodeError(error) && (!(error instanceof Error) || !error.message.includes("run state"))) throw error;
+      if (!isNodeError(error) && (!(error instanceof Error) || !error.message.includes("run state")))
+        throw error;
     }
   }
   const runs = await listRuns(sessionCwd);
-  const match = runs.find((entry) => entry.id === run || entry.name === run || entry.path === run || entry.path.endsWith(`/${run}`));
+  const match = runs.find(
+    (entry) => entry.id === run || entry.name === run || entry.path === run || entry.path.endsWith(`/${run}`)
+  );
   if (!match) throw new Error(`Unknown run: ${run}`);
   return match.path;
 }
 function runRootCandidates(sessionCwd, run) {
   const candidates = [isAbsolute(run) ? run : resolve(sessionCwd, run)];
-  if (!isAbsolute(run)) candidates.push(resolve(sessionCwd, ".norn", "runs", run));
+  if (!isAbsolute(run))
+    candidates.push(resolve(sessionCwd, ".norn", "runs", run));
   return Array.from(new Set(candidates));
 }
 async function getPendingResumeHealth(runRoot, requestedAt) {
@@ -262,7 +365,10 @@ async function getLaunchedRunInfo(runRoot) {
     id: launchRequest.id,
     name: launchRequest.name,
     path: runRoot,
-    paths: { project: resolve(runRoot, "../../.."), workspace: join(runCurrentRoot(resolve(runRoot)), "workspace") },
+    paths: {
+      project: resolve(runRoot, "../../.."),
+      workspace: join(runCurrentRoot(resolve(runRoot)), "workspace")
+    },
     entrypointWorkflowId: launchRequest.workflowId,
     currentWorkflowId: launchRequest.workflowId,
     status: "running",
@@ -272,7 +378,10 @@ async function getLaunchedRunInfo(runRoot) {
   };
 }
 async function readRunStateJson(currentRoot) {
-  return readRunStateFile({ path: join(currentRoot, RUN_STATE_FILE_NAME), legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME) });
+  return readRunStateFile({
+    path: join(currentRoot, RUN_STATE_FILE_NAME),
+    legacyPath: join(currentRoot, LEGACY_RUN_STATE_FILE_NAME)
+  });
 }
 async function readRunStateFile(input) {
   try {
@@ -286,35 +395,50 @@ function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function assertRunVersion(version) {
-  if (version !== RUN_STATE_VERSION) throw new Error(`Incompatible saved run state version ${String(version)}; this alpha requires version ${RUN_STATE_VERSION}. Use the original Norn version to resume this run, or start a new run. Saved files have not been migrated.`);
+  if (version !== RUN_STATE_VERSION)
+    throw new Error(
+      `Incompatible saved run state version ${String(version)}; this alpha requires version ${RUN_STATE_VERSION}. Use the original Norn version to resume this run, or start a new run. Saved files have not been migrated.`
+    );
 }
 function parseNornRunState(value, mode) {
   if (!value || typeof value !== "object") throw new Error("Invalid run state");
   const state = value;
-  if (mode === "execute" || state.version !== 1) assertRunVersion(state.version);
-  if (typeof state.id !== "string" || state.id.length === 0) throw new Error("Invalid run state id");
+  if (mode === "execute" || state.version !== 1)
+    assertRunVersion(state.version);
+  if (typeof state.id !== "string" || state.id.length === 0)
+    throw new Error("Invalid run state id");
   const normalizedState = state;
-  if (typeof normalizedState.name !== "string" || normalizedState.name.length === 0) normalizedState.name = state.id;
-  if (typeof normalizedState.entrypointWorkflowId !== "string" && typeof normalizedState.rootWorkflowId === "string") normalizedState.entrypointWorkflowId = normalizedState.rootWorkflowId;
-  if (typeof state.entrypointWorkflowId !== "string" || state.entrypointWorkflowId.length === 0) throw new Error("Invalid run state entrypoint workflow id");
-  if (typeof state.workspace !== "string" || state.workspace.length === 0) throw new Error("Invalid run state workspace");
-  if (state.status !== "running" && state.status !== "interrupted" && state.status !== "stopped" && state.status !== "pendingResume" && state.status !== "completed" && state.status !== "failed") throw new Error("Invalid run state status");
+  if (typeof normalizedState.name !== "string" || normalizedState.name.length === 0)
+    normalizedState.name = state.id;
+  if (typeof normalizedState.entrypointWorkflowId !== "string" && typeof normalizedState.rootWorkflowId === "string")
+    normalizedState.entrypointWorkflowId = normalizedState.rootWorkflowId;
+  if (typeof state.entrypointWorkflowId !== "string" || state.entrypointWorkflowId.length === 0)
+    throw new Error("Invalid run state entrypoint workflow id");
+  if (typeof state.workspace !== "string" || state.workspace.length === 0)
+    throw new Error("Invalid run state workspace");
+  if (state.status !== "running" && state.status !== "interrupted" && state.status !== "stopped" && state.status !== "pendingResume" && state.status !== "completed" && state.status !== "failed")
+    throw new Error("Invalid run state status");
   if (state.status === "interrupted") assertInterruptedNornRunState(state);
-  if (state.status === "stopped" || state.status === "pendingResume") assertResumableNornRunState(state);
-  if (typeof state.startedAt !== "string" || typeof state.updatedAt !== "string") throw new Error("Invalid run state timestamps");
+  if (state.status === "stopped" || state.status === "pendingResume")
+    assertResumableNornRunState(state);
+  if (typeof state.startedAt !== "string" || typeof state.updatedAt !== "string")
+    throw new Error("Invalid run state timestamps");
   return state;
 }
 function assertInterruptedNornRunState(state) {
   if (!state.current) throw new Error("Invalid interrupted run current step");
   const interruption = state.current.interruption;
-  if (!interruption || interruption.status !== "pending") throw new Error("Invalid run interruption");
-  if (typeof interruption.description !== "string" || interruption.description.length === 0) throw new Error("Invalid run interruption description");
+  if (!interruption || interruption.status !== "pending")
+    throw new Error("Invalid run interruption");
+  if (typeof interruption.description !== "string" || interruption.description.length === 0)
+    throw new Error("Invalid run interruption description");
 }
 function assertResumableNornRunState(state) {
   if (!state.current) throw new Error("Invalid resumable run current step");
 }
 function runInterruption(state) {
-  if (state.status !== "interrupted" || !state.current?.interruption) return void 0;
+  if (state.status !== "interrupted" || !state.current?.interruption)
+    return void 0;
   return {
     workflowId: state.current.workflowId,
     args: state.version === 1 ? state.current.params : state.current.args,