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

package/dist/internal/metrics.d.ts

@@ -0,0 +1,19 @@
+import type { NornRunMetrics, NornRunStatus } from "@vimhead.dev/norn";
+type NornRunManifestEvent = Record<string, unknown> & {
+    readonly at?: string;
+    readonly type?: string;
+};
+type NornRunStateSnapshot = {
+    readonly status?: NornRunStatus;
+    readonly startedAt?: string;
+    readonly updatedAt?: string;
+    readonly outcome?: {
+        readonly completedAt?: string;
+    } | null;
+    readonly failed?: {
+        readonly failedAt?: string;
+    } | null;
+};
+export declare function readRunMetrics(runRoot: string): Promise<NornRunMetrics>;
+export declare function calculateRunMetrics(events: readonly NornRunManifestEvent[], state: NornRunStateSnapshot, now: Date): NornRunMetrics;
+export {};

package/dist/internal/metrics.js

@@ -0,0 +1,282 @@
+// src/internal/metrics.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { runCurrentRoot } from "./run-store.js";
+import { RUN_STATE_FILE_NAME } from "./run-state.js";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/internal/metrics.ts
+import { addAgentUsage, agentUsageFromValue, emptyAgentUsage } from "./usage.js";
+var LEGACY_RUN_STATE_FILE_NAME = "runtime-state.json";
+async function readRunMetrics(runRoot) {
+  const currentRoot = runCurrentRoot(runRoot);
+  const [state, events] = await Promise.all([
+    readRunStateSnapshot(currentRoot),
+    readManifestEvents(join(currentRoot, "manifest.json"))
+  ]);
+  return calculateRunMetrics(events, state, /* @__PURE__ */ new Date());
+}
+function calculateRunMetrics(events, state, now) {
+  const startedAt = state.startedAt ?? firstEventTime(events) ?? now.toISOString();
+  const endedAt = runEndedAt(state);
+  const startedAtMs = timestampMs(startedAt) ?? now.getTime();
+  const endedAtMs = timestampMs(endedAt) ?? now.getTime();
+  const workflows = [];
+  let openWorkflow;
+  let gateStartedAtMs;
+  let gateWaitMs = 0;
+  let agentUsage = emptyAgentUsage();
+  for (const event of events) {
+    const eventAtMs = timestampMs(event.at);
+    if (event.type === "run.interrupted" && eventAtMs !== void 0) gateStartedAtMs = eventAtMs;
+    else if (event.type === "run.resumed" && eventAtMs !== void 0 && gateStartedAtMs !== void 0) {
+      gateWaitMs += Math.max(0, eventAtMs - gateStartedAtMs);
+      gateStartedAtMs = void 0;
+    }
+    if (event.type === "workflow.started") {
+      openWorkflow = {
+        workflowId: stringField(event.workflowId, "unknown"),
+        startedAt: isoTime(event.at, now),
+        startedAtMs: eventAtMs ?? now.getTime(),
+        agents: [],
+        commands: [],
+        openAgents: [],
+        openCommands: []
+      };
+      continue;
+    }
+    if (event.type === "agent.started") {
+      if (openWorkflow) openWorkflow = startAgentMetrics(openWorkflow, event, now);
+      continue;
+    }
+    if (event.type === "agent.completed" || event.type === "agent.failed") {
+      const usage = agentUsageFromEvent(event);
+      agentUsage = addAgentUsage(agentUsage, usage);
+      if (openWorkflow) openWorkflow = finishAgentMetrics(openWorkflow, event, usage, now);
+      continue;
+    }
+    if (event.type === "command.started") {
+      if (openWorkflow) openWorkflow = startCommandMetrics(openWorkflow, event, now);
+      continue;
+    }
+    if (event.type === "command.completed" || event.type === "command.failed") {
+      if (openWorkflow) openWorkflow = finishCommandMetrics(openWorkflow, event, now);
+      continue;
+    }
+    const status = workflowTerminalStatus(event.type);
+    if (status) {
+      const durationMs = numberField(event.durationMs) || (openWorkflow && eventAtMs !== void 0 ? Math.max(0, eventAtMs - openWorkflow.startedAtMs) : 0);
+      const workflowId = status === "transitioned" ? stringField(event.fromWorkflowId, openWorkflow?.workflowId ?? "unknown") : stringField(event.workflowId, openWorkflow?.workflowId ?? "unknown");
+      const workflow = openWorkflow ?? createSyntheticWorkflowMetrics(workflowId, startedAtMs, endedAtMs, eventAtMs, durationMs);
+      const childStatus = status === "failed" ? "failed" : "completed";
+      workflows.push(closeWorkflowMetrics(closeOpenChildMetrics(workflow, eventAtMs ?? now.getTime(), event.at, childStatus), workflows.length + 1, status, durationMs, event.at));
+      openWorkflow = void 0;
+    }
+  }
+  if (gateStartedAtMs !== void 0) gateWaitMs += Math.max(0, endedAtMs - gateStartedAtMs);
+  if (openWorkflow) {
+    workflows.push(closeWorkflowMetrics(closeOpenChildMetrics(openWorkflow, endedAtMs, endedAt, "running"), workflows.length + 1, "running", Math.max(0, endedAtMs - openWorkflow.startedAtMs), endedAt));
+  }
+  const workflowsMs = workflows.reduce((sum, workflow) => sum + workflow.wallMs, 0);
+  const agentsMs = workflows.reduce((sum, workflow) => sum + workflow.agentsMs, 0);
+  const commandsMs = workflows.reduce((sum, workflow) => sum + workflow.commandsMs, 0);
+  const wallMs = Math.max(0, endedAtMs - startedAtMs);
+  return {
+    status: state.status ?? "running",
+    startedAt,
+    ...endedAt === void 0 ? {} : { endedAt },
+    wallMs,
+    activeMs: Math.max(0, wallMs - gateWaitMs),
+    gateWaitMs,
+    workflowsMs,
+    workflowOwnMs: Math.max(0, workflowsMs - agentsMs - commandsMs),
+    agentsMs,
+    commandsMs,
+    agentUsage,
+    workflows
+  };
+}
+async function readRunStateSnapshot(currentRoot) {
+  try {
+    return JSON.parse(await readFile(join(currentRoot, RUN_STATE_FILE_NAME), "utf8"));
+  } catch (error) {
+    if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+    return JSON.parse(await readFile(join(currentRoot, LEGACY_RUN_STATE_FILE_NAME), "utf8"));
+  }
+}
+async function readManifestEvents(path) {
+  const manifest = JSON.parse(await readFile(path, "utf8"));
+  return manifest.events ?? [];
+}
+function createSyntheticWorkflowMetrics(workflowId, runStartedAtMs, runEndedAtMs, eventAtMs, durationMs) {
+  const startedAtMs = eventAtMs === void 0 ? runEndedAtMs : Math.max(runStartedAtMs, eventAtMs - durationMs);
+  return {
+    workflowId,
+    startedAt: isoTimeFromMs(startedAtMs),
+    startedAtMs,
+    agents: [],
+    commands: [],
+    openAgents: [],
+    openCommands: []
+  };
+}
+function startAgentMetrics(workflow, event, now) {
+  return {
+    ...workflow,
+    openAgents: [...workflow.openAgents, {
+      label: stringField(event.label, "unknown"),
+      startedAt: isoTime(event.at, now),
+      startedAtMs: timestampMs(event.at) ?? now.getTime()
+    }]
+  };
+}
+function finishAgentMetrics(workflow, event, usage, now) {
+  const [agent, openAgents] = takeOpenChild(workflow.openAgents, stringField(event.label, "unknown"));
+  const closedAgent = closeAgentMetrics(event, workflow.agents.length + 1, usage, now, agent);
+  return { ...workflow, agents: [...workflow.agents, closedAgent], openAgents };
+}
+function startCommandMetrics(workflow, event, now) {
+  return {
+    ...workflow,
+    openCommands: [...workflow.openCommands, {
+      label: stringField(event.label, "unknown"),
+      startedAt: isoTime(event.at, now),
+      startedAtMs: timestampMs(event.at) ?? now.getTime()
+    }]
+  };
+}
+function finishCommandMetrics(workflow, event, now) {
+  const [command, openCommands] = takeOpenChild(workflow.openCommands, stringField(event.label, "unknown"));
+  const closedCommand = closeCommandMetrics(event, workflow.commands.length + 1, now, command);
+  return { ...workflow, commands: [...workflow.commands, closedCommand], openCommands };
+}
+function closeOpenChildMetrics(workflow, endedAtMs, endedAt, status) {
+  return {
+    ...workflow,
+    agents: [
+      ...workflow.agents,
+      ...workflow.openAgents.map((agent, offset) => ({
+        index: workflow.agents.length + offset + 1,
+        label: agent.label,
+        status,
+        startedAt: agent.startedAt,
+        ...endedAt === void 0 ? {} : { endedAt },
+        wallMs: Math.max(0, endedAtMs - agent.startedAtMs),
+        usage: emptyAgentUsage()
+      }))
+    ],
+    commands: [
+      ...workflow.commands,
+      ...workflow.openCommands.map((command, offset) => ({
+        index: workflow.commands.length + offset + 1,
+        label: command.label,
+        status,
+        startedAt: command.startedAt,
+        ...endedAt === void 0 ? {} : { endedAt },
+        wallMs: Math.max(0, endedAtMs - command.startedAtMs)
+      }))
+    ],
+    openAgents: [],
+    openCommands: []
+  };
+}
+function closeWorkflowMetrics(workflow, index, status, wallMs, endedAt) {
+  const agentsMs = workflow.agents.reduce((sum, agent) => sum + agent.wallMs, 0);
+  const commandsMs = workflow.commands.reduce((sum, command) => sum + command.wallMs, 0);
+  return {
+    index,
+    workflowId: workflow.workflowId,
+    status,
+    startedAt: workflow.startedAt,
+    ...endedAt === void 0 ? {} : { endedAt },
+    wallMs,
+    ownMs: Math.max(0, wallMs - agentsMs - commandsMs),
+    agentsMs,
+    commandsMs,
+    agentUsage: workflow.agents.reduce((sum, agent) => addAgentUsage(sum, agent.usage), emptyAgentUsage()),
+    agents: workflow.agents,
+    commands: workflow.commands
+  };
+}
+function closeAgentMetrics(event, index, usage, now, openAgent) {
+  const endedAtMs = timestampMs(event.at) ?? now.getTime();
+  const wallMs = numberField(event.durationMs) || (openAgent ? Math.max(0, endedAtMs - openAgent.startedAtMs) : 0);
+  return {
+    index,
+    label: stringField(event.label, openAgent?.label ?? "unknown"),
+    status: event.type === "agent.failed" ? "failed" : "completed",
+    startedAt: openAgent?.startedAt ?? isoTimeFromMs(Math.max(0, endedAtMs - wallMs)),
+    endedAt: isoTime(event.at, now),
+    wallMs,
+    attempts: optionalNumberField(event.attempts),
+    usage
+  };
+}
+function closeCommandMetrics(event, index, now, openCommand) {
+  const endedAtMs = timestampMs(event.at) ?? now.getTime();
+  const wallMs = numberField(event.durationMs) || (openCommand ? Math.max(0, endedAtMs - openCommand.startedAtMs) : 0);
+  return {
+    index,
+    label: stringField(event.label, openCommand?.label ?? "unknown"),
+    status: event.type === "command.failed" ? "failed" : "completed",
+    startedAt: openCommand?.startedAt ?? isoTimeFromMs(Math.max(0, endedAtMs - wallMs)),
+    endedAt: isoTime(event.at, now),
+    wallMs,
+    ...event.type === "command.completed" ? { exitCode: nullableNumberField(event.exitCode), killed: booleanField(event.killed) } : {}
+  };
+}
+function takeOpenChild(children, label) {
+  const index = children.findIndex((child) => child.label === label);
+  if (index === -1) return [void 0, children];
+  return [children[index], [...children.slice(0, index), ...children.slice(index + 1)]];
+}
+function workflowTerminalStatus(type) {
+  if (type === "workflow.completed") return "completed";
+  if (type === "workflow.failed") return "failed";
+  if (type === "workflow.transitioned") return "transitioned";
+  return void 0;
+}
+function runEndedAt(state) {
+  if (state.status === "completed") return state.outcome?.completedAt ?? state.updatedAt;
+  if (state.status === "failed") return state.failed?.failedAt ?? state.outcome?.completedAt ?? state.updatedAt;
+  return void 0;
+}
+function agentUsageFromEvent(event) {
+  return agentUsageFromValue(event.usage) ?? emptyAgentUsage();
+}
+function firstEventTime(events) {
+  return events.find((event) => timestampMs(event.at) !== void 0)?.at;
+}
+function timestampMs(value) {
+  const parsed = value ? Date.parse(value) : NaN;
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function isoTime(value, now) {
+  return value && timestampMs(value) !== void 0 ? value : now.toISOString();
+}
+function isoTimeFromMs(value) {
+  return new Date(value).toISOString();
+}
+function numberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function optionalNumberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function nullableNumberField(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function booleanField(value) {
+  return typeof value === "boolean" ? value : false;
+}
+function stringField(value, fallback) {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+export {
+  calculateRunMetrics,
+  readRunMetrics
+};

package/dist/internal/pi-assets.d.ts

@@ -0,0 +1,13 @@
+export type PiAssetFile = {
+    readonly path: string;
+    readonly content: string;
+};
+export declare function resolvePiAssetsCacheRoot(input: {
+    readonly platform: string;
+    readonly home: string;
+    readonly environment: Readonly<Record<string, string | undefined>>;
+}): string;
+export declare function materializePiAssets(input: {
+    readonly archive: string;
+    readonly cacheRoot: string;
+}): Promise<string>;

package/dist/internal/pi-assets.js

@@ -0,0 +1,94 @@
+// src/internal/pi-assets.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { gunzipSync } from "node:zlib";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/internal/pi-assets.ts
+function resolvePiAssetsCacheRoot(input) {
+  if (input.environment.NORN_PI_CACHE_DIR) return resolve(input.environment.NORN_PI_CACHE_DIR);
+  if (input.platform === "darwin") return join(input.home, "Library", "Caches", "norn", "pi");
+  if (input.platform === "win32") return join(input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"), "norn", "pi");
+  const xdgCache = input.environment.XDG_CACHE_HOME;
+  return join(xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"), "norn", "pi");
+}
+async function materializePiAssets(input) {
+  const digest = createHash("sha256").update(input.archive).digest("hex");
+  const files = JSON.parse(gunzipSync(Buffer.from(input.archive, "base64")).toString("utf8"));
+  const expectedFiles = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.path || file.path.includes("\\") || file.path.includes(":") || file.path.split("/").some((part) => !part || part === "." || part === "..") || expectedFiles.has(file.path)) {
+      throw new Error("Invalid bundled Pi asset path");
+    }
+    expectedFiles.set(file.path, Buffer.from(file.content, "base64"));
+  }
+  return new PiAssetCache({ cacheRoot: input.cacheRoot, digest, expectedFiles }).materialize();
+}
+var PiAssetCache = class {
+  constructor(input) {
+    this.input = input;
+    this.root = join(input.cacheRoot, `v1-${input.digest}`);
+  }
+  input;
+  root;
+  async materialize() {
+    await mkdir(this.input.cacheRoot, { recursive: true, mode: 448 });
+    if (!(await lstat(this.input.cacheRoot)).isDirectory()) throw new Error("Pi asset cache root must be a real directory");
+    if (await this.validateExistingCache()) return this.root;
+    const staging = await mkdtemp(join(this.input.cacheRoot, ".extract-"));
+    try {
+      for (const [path, content] of this.input.expectedFiles) {
+        const parts = path.split("/");
+        await mkdir(join(staging, ...parts.slice(0, -1)), { recursive: true, mode: 448 });
+        await writeFile(join(staging, ...parts), content, { flag: "wx", mode: 384 });
+      }
+      try {
+        await rename(staging, this.root);
+      } catch (error) {
+        if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "") || !await this.validateExistingCache()) throw error;
+      }
+      if (!await this.validateExistingCache()) throw new Error("Pi assets disappeared after extraction");
+      return this.root;
+    } finally {
+      await rm(staging, { recursive: true, force: true });
+    }
+  }
+  async validateExistingCache() {
+    try {
+      if (!(await lstat(this.root)).isDirectory()) throw this.invalidCacheError();
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return false;
+      throw error;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    await this.validateDirectory({ directory: this.root, prefix: "", seen });
+    if (seen.size !== this.input.expectedFiles.size) throw this.invalidCacheError();
+    return true;
+  }
+  async validateDirectory(input) {
+    for (const entry of await readdir(input.directory, { withFileTypes: true })) {
+      const path = input.prefix ? `${input.prefix}/${entry.name}` : entry.name;
+      const absolutePath = join(input.directory, entry.name);
+      if (entry.isDirectory()) {
+        if (![...this.input.expectedFiles.keys()].some((file) => file.startsWith(`${path}/`))) throw this.invalidCacheError();
+        await this.validateDirectory({ directory: absolutePath, prefix: path, seen: input.seen });
+      } else {
+        const expected = this.input.expectedFiles.get(path);
+        if (!entry.isFile() || !expected || !(await readFile(absolutePath)).equals(expected)) throw this.invalidCacheError();
+        input.seen.add(path);
+      }
+    }
+  }
+  invalidCacheError() {
+    return new Error(`Bundled Pi assets are incomplete or modified: ${this.root}. Remove this cache entry and retry.`);
+  }
+};
+export {
+  materializePiAssets,
+  resolvePiAssetsCacheRoot
+};

package/dist/internal/resource-bindings.d.ts

@@ -0,0 +1,13 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { NornAgentResourceAdapter } from "@vimhead.dev/norn";
+export declare class NornSessionResourceBindings {
+    readonly tools: ToolDefinition[];
+    private readonly bindings;
+    bind(input: {
+        readonly adapters: readonly NornAgentResourceAdapter[];
+        readonly runId: string;
+        readonly label: string;
+        readonly reservedTools: readonly string[];
+    }): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/internal/resource-bindings.js

@@ -0,0 +1,34 @@
+// src/internal/resource-bindings.ts
+var NornSessionResourceBindings = class {
+  tools = [];
+  bindings = [];
+  async bind(input) {
+    const adapterNames = /* @__PURE__ */ new Set();
+    const tools = new Set(input.reservedTools);
+    for (const adapter of input.adapters) {
+      if (adapterNames.has(adapter.name)) throw new Error(`Duplicate resource adapter: ${adapter.name}`);
+      adapterNames.add(adapter.name);
+      const binding = await adapter.bind({ runId: input.runId, label: input.label });
+      this.bindings.push(binding);
+      for (const tool of binding.tools) {
+        if (tools.has(tool.name)) throw new Error(`Resource tool name collision: ${tool.name}`);
+        tools.add(tool.name);
+        this.tools.push(tool);
+      }
+    }
+  }
+  async dispose() {
+    const errors = [];
+    for (const binding of this.bindings.splice(0).reverse()) {
+      try {
+        await binding.dispose();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length) throw new AggregateError(errors, "Resource binding cleanup failed");
+  }
+};
+export {
+  NornSessionResourceBindings
+};

package/dist/internal/run-lease.d.ts

@@ -0,0 +1,32 @@
+import type { NornRunHealth } from "@vimhead.dev/norn";
+export type NornRunLeaseOwner = {
+    readonly token: string;
+    readonly acquiredAt: string;
+    readonly heartbeatAt: string;
+    readonly pid: number;
+    readonly processGroupId: number;
+    readonly command: readonly string[];
+};
+export declare class NornRunLease {
+    private readonly lockRoot;
+    private readonly token;
+    private readonly processOwner;
+    private heartbeat;
+    private heartbeatChain;
+    private isReleased;
+    private constructor();
+    static acquire(runRoot: string, processOwner?: NornRunProcessOwner): Promise<NornRunLease>;
+    assertOwned(): Promise<void>;
+    release(): Promise<void>;
+    private get ownerPath();
+    private startHeartbeat;
+    private refreshHeartbeat;
+    private writeOwner;
+}
+export type NornRunProcessOwner = {
+    readonly pid: number;
+    readonly processGroupId: number;
+    readonly command: readonly string[];
+};
+export declare function getRunLeaseHealth(runRoot: string): Promise<NornRunHealth>;
+export declare function getRunLeaseOwner(runRoot: string): Promise<NornRunLeaseOwner | undefined>;

package/dist/internal/run-lease.js

@@ -0,0 +1,166 @@
+// src/internal/run-lease.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, readFile, rm as rm2, stat as stat2 } from "node:fs/promises";
+import { join } from "node:path";
+
+// ../core/src/errors.ts
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// ../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";
+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/run-lease.ts
+var LOCK_DIR_NAME = "active.lock";
+var OWNER_FILE_NAME = "owner.json";
+var HEARTBEAT_INTERVAL_MS = 15e3;
+var HEARTBEAT_TTL_MS = 6e4;
+var ACQUIRE_ATTEMPTS = 5;
+var NornRunLease = class _NornRunLease {
+  constructor(lockRoot, token, processOwner) {
+    this.lockRoot = lockRoot;
+    this.token = token;
+    this.processOwner = processOwner;
+  }
+  lockRoot;
+  token;
+  processOwner;
+  heartbeat;
+  heartbeatChain = Promise.resolve();
+  isReleased = false;
+  static async acquire(runRoot, processOwner = currentRunProcessOwner()) {
+    const lockRoot = join(runRoot, LOCK_DIR_NAME);
+    for (let attempt = 1; attempt <= ACQUIRE_ATTEMPTS; attempt++) {
+      try {
+        await mkdir2(lockRoot);
+        const lease = new _NornRunLease(lockRoot, randomUUID2(), processOwner);
+        try {
+          await lease.writeOwner({ acquiredAt: (/* @__PURE__ */ new Date()).toISOString() });
+        } catch (error) {
+          await rm2(lockRoot, { recursive: true, force: true });
+          throw error;
+        }
+        lease.startHeartbeat();
+        return lease;
+      } catch (error) {
+        if (!isNodeError(error) || error.code !== "EEXIST") throw error;
+        const owner = await readRunLeaseOwner(join(lockRoot, OWNER_FILE_NAME));
+        const isStale = owner ? isRunLeaseStale(owner) : await isRunLeaseDirectoryStale(lockRoot);
+        if (!isStale) throw new Error(`Run is already active: ${runRoot}`);
+        await rm2(lockRoot, { recursive: true, force: true });
+      }
+    }
+    throw new Error(`Could not acquire run lease: ${runRoot}`);
+  }
+  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");
+  }
+  async release() {
+    if (this.isReleased) return;
+    this.isReleased = true;
+    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 });
+  }
+  get ownerPath() {
+    return join(this.lockRoot, OWNER_FILE_NAME);
+  }
+  startHeartbeat() {
+    this.heartbeat = setInterval(() => {
+      this.heartbeatChain = this.heartbeatChain.then(() => this.refreshHeartbeat()).catch(() => {
+        this.isReleased = true;
+        if (this.heartbeat) clearInterval(this.heartbeat);
+      });
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeat.unref?.();
+  }
+  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");
+    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 });
+  }
+};
+async function getRunLeaseHealth(runRoot) {
+  const lockRoot = join(runRoot, LOCK_DIR_NAME);
+  const owner = await readRunLeaseOwner(join(lockRoot, OWNER_FILE_NAME));
+  if (owner) return isRunLeaseStale(owner) ? "unhealthy" : "healthy";
+  return await isRunLeaseDirectoryStale(lockRoot) ? "unhealthy" : "healthy";
+}
+async function getRunLeaseOwner(runRoot) {
+  return readRunLeaseOwner(join(runRoot, LOCK_DIR_NAME, OWNER_FILE_NAME));
+}
+function currentRunProcessOwner() {
+  return {
+    pid: process.pid,
+    processGroupId: process.pid,
+    command: process.argv
+  };
+}
+async function readRunLeaseOwner(path) {
+  try {
+    return parseRunLeaseOwner(JSON.parse(await readFile(path, "utf8")));
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    return void 0;
+  }
+}
+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;
+  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 };
+}
+function isRunLeaseStale(owner) {
+  return Date.now() - Date.parse(owner.heartbeatAt) > HEARTBEAT_TTL_MS;
+}
+async function isRunLeaseDirectoryStale(lockRoot) {
+  try {
+    return Date.now() - (await stat2(lockRoot)).mtimeMs > HEARTBEAT_TTL_MS;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return true;
+    throw error;
+  }
+}
+export {
+  NornRunLease,
+  getRunLeaseHealth,
+  getRunLeaseOwner
+};