@nodii/dev 0.6.27 → 0.6.29

package/dist/runtime-launcher.js

@@ -0,0 +1,270 @@
+import { spawn } from "node:child_process";
+import * as fsPromises from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { configPath } from "./core.js";
+import { recordWatchedRun } from "./watchdog.js";
+
+const RUNTIMES = new Set(["codex", "claude"]);
+
+const requiredText = (value, name) => {
+  if (typeof value !== "string" || !value.trim())
+    throw new TypeError(`${name} must be a non-empty string`);
+  return value;
+};
+
+const absolutePath = (value, name) => {
+  requiredText(value, name);
+  if (!isAbsolute(value) || resolve(value) !== value)
+    throw new TypeError(`${name} must be an absolute, normalized path`);
+  return value;
+};
+
+const printable = (value) => {
+  if (value === undefined || value === null || value === "") return "(none)";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2);
+};
+
+const dataFrom = (payload) => {
+  if (!payload || typeof payload !== "object" || !payload.data || typeof payload.data !== "object")
+    throw new TypeError("recovery payload must contain data");
+  return payload.data;
+};
+
+function validateData(data) {
+  const runId = requiredText(data?.run?.id, "run.id");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId))
+    throw new TypeError("run.id is not a safe state-directory name");
+  const laneKey = requiredText(data?.lane?.key, "lane.key");
+  const runtime = requiredText(data?.launch?.runtime, "launch.runtime");
+  if (!RUNTIMES.has(runtime))
+    throw new TypeError("launch.runtime must be codex or claude");
+  const model = requiredText(data?.launch?.model, "launch.model");
+  const cwd = absolutePath(data?.launch?.cwd, "launch.cwd");
+  const addDirs = data?.launch?.addDirs ?? [];
+  if (!Array.isArray(addDirs)) throw new TypeError("launch.addDirs must be an array");
+  for (const [index, path] of addDirs.entries())
+    absolutePath(path, `launch.addDirs[${index}]`);
+  return { runId, laneKey, runtime, model, cwd, addDirs };
+}
+
+function validateLaunch(options) {
+  const runId = requiredText(options?.runId, "runId");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(runId))
+    throw new TypeError("runId is not a safe state-directory name");
+  const laneKey = requiredText(options?.laneKey, "laneKey");
+  const runtime = requiredText(options?.runtime, "runtime");
+  if (!RUNTIMES.has(runtime)) throw new TypeError("runtime must be codex or claude");
+  const model = requiredText(options?.model, "model");
+  const cwd = absolutePath(options?.cwd, "cwd");
+  const devConfigPath = absolutePath(options?.devConfigPath, "devConfigPath");
+  const addDirs = options?.addDirs ?? [];
+  if (!Array.isArray(addDirs)) throw new TypeError("addDirs must be an array");
+  for (const [index, path] of addDirs.entries()) absolutePath(path, `addDirs[${index}]`);
+  const prompt = requiredText(options?.prompt, "prompt");
+  return { runId, laneKey, runtime, model, cwd, devConfigPath, addDirs, prompt, profileHome: options.profileHome };
+}
+
+function profileVariable(runtime, profileHome, home) {
+  if (profileHome === undefined || profileHome === null) return {};
+  absolutePath(profileHome, "launch.profileHome");
+  absolutePath(home, "home");
+  const child = relative(home, profileHome);
+  const expected = runtime === "codex" ? /^\.codex(?:[-_.][A-Za-z0-9._-]+)?$/ : /^\.claude(?:[-_.][A-Za-z0-9._-]+)?$/;
+  if (!child || child.startsWith("..") || isAbsolute(child) || child.includes("/") || !expected.test(basename(profileHome)))
+    throw new TypeError(`launch.profileHome must be a safe ${runtime} profile directory directly under home`);
+  return runtime === "codex"
+    ? { CODEX_HOME: profileHome }
+    : { CLAUDE_CONFIG_DIR: profileHome };
+}
+
+/** Build the complete recovery message passed to the fresh runtime over stdin. */
+export function buildRecoveryPrompt(data) {
+  const { runId, laneKey } = validateData(data);
+  return [
+    `You are lane ${laneKey}, relaunched as fresh run ${runId} after an orphaned process.`,
+    "Continue from the recorded next step. Do not redo finished lane steps.",
+    "",
+    `Next step:\n${printable(data.lane.next)}`,
+    "",
+    `Last pushed commit:\n${printable(data.recovery?.lastPushedCommit)}`,
+    "",
+    `Freeze:\n${printable(data.recovery?.freeze)}`,
+    "",
+    `Dead run log tail:\n${printable(data.recovery?.logTail)}`,
+    "",
+  ].join("\n");
+}
+
+/** Build an allowlisted, fresh headless runtime invocation. No prompt is put in argv. */
+export function buildRecoveryInvocation(data, { env = process.env, home = homedir() } = {}) {
+  const { runId, laneKey, runtime, model, cwd, addDirs } = validateData(data);
+  const devConfigPath = absolutePath(data?.launch?.devConfigPath, "launch.devConfigPath");
+  return buildInvocation({ runId, laneKey, runtime, model, cwd, addDirs, profileHome: data.launch.profileHome, devConfigPath }, { env, home });
+}
+
+function buildInvocation(options, { env = process.env, home = homedir() } = {}) {
+  const { runId, laneKey, runtime, model, cwd, addDirs, profileHome, devConfigPath } = options;
+  const args = runtime === "codex"
+    ? ["exec", "--json", "--cd", cwd, "--model", model, ...addDirs.flatMap((path) => ["--add-dir", path]), "-"]
+    : ["--print", "--output-format", "stream-json", "--model", model, ...addDirs.flatMap((path) => ["--add-dir", path])];
+  return {
+    command: runtime,
+    args,
+    cwd,
+    env: {
+      ...env,
+      NODII_DEV_RUN_ID: runId,
+      NODII_DEV_LANE_KEY: laneKey,
+      NODII_DEV_CONFIG_PATH: devConfigPath,
+      ...profileVariable(runtime, profileHome, home),
+    },
+  };
+}
+
+const closeQuietly = async (handle) => {
+  try {
+    await handle?.close?.();
+  } catch {}
+};
+
+export function recoveryStateRoot(path = configPath()) {
+  const configDir = dirname(path);
+  const nodiiDir = basename(configDir) === "agents" ? dirname(configDir) : configDir;
+  return join(nodiiDir, "runs");
+}
+
+async function launchDetached({ invocation, prompt, runId, laneKey, devConfigPath }, {
+  spawnImpl,
+  fs,
+  stateRoot,
+  watch,
+  terminate,
+}) {
+  absolutePath(stateRoot, "stateRoot");
+  const runDir = join(stateRoot, runId);
+  const logPath = join(runDir, "process.log");
+  const pidPath = join(runDir, "process.pid");
+
+  await fs.mkdir(runDir, { recursive: true, mode: 0o700 });
+  const log = await fs.open(logPath, "a", 0o600);
+  try {
+    await fs.chmod(logPath, 0o600);
+  } catch (error) {
+    await closeQuietly(log);
+    throw error;
+  }
+
+  let child;
+  try {
+    child = spawnImpl(invocation.command, invocation.args, {
+      cwd: invocation.cwd,
+      env: invocation.env,
+      shell: false,
+      detached: true,
+      stdio: ["pipe", log.fd, log.fd],
+    });
+  } catch (error) {
+    await closeQuietly(log);
+    throw error;
+  }
+
+  return new Promise((resolveLaunch, rejectLaunch) => {
+    let settled = false;
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      closeQuietly(log).finally(() => rejectLaunch(error));
+    });
+    child.once("spawn", () => {
+      if (settled) return;
+      settled = true;
+      (async () => {
+        if (!Number.isInteger(child.pid) || child.pid <= 0)
+          throw new Error("runtime process spawned without a PID");
+        await fs.writeFile(pidPath, `${child.pid}\n`, { mode: 0o600, flag: "w" });
+        try {
+          await watch({ runId, pid: child.pid, configPath: devConfigPath, worktree: invocation.cwd });
+        } catch (error) {
+          // This exact child has already been recorded in its private PID file.
+          // Do not leave an untracked runtime alive when registry persistence fails.
+          await terminate(child);
+          throw error;
+        }
+        if (!child.stdin || typeof child.stdin.end !== "function")
+          throw new Error("runtime process has no stdin pipe");
+        child.stdin.end(prompt);
+        await closeQuietly(log);
+        child.unref();
+        resolveLaunch({
+          runId,
+          laneKey,
+          pid: child.pid,
+          logPath,
+          pidPath,
+          command: invocation.command,
+          args: invocation.args,
+          cwd: invocation.cwd,
+        });
+      })().catch(async (error) => {
+        await closeQuietly(log);
+        rejectLaunch(error);
+      });
+    });
+  });
+}
+
+const terminateChild = async (child) => {
+  if (typeof child.kill === "function") child.kill("SIGTERM");
+};
+
+/** Launch a newly registered lane with its lane-scoped Dev identity. */
+export async function launchRuntime(options, {
+  spawnImpl = spawn,
+  fs = fsPromises,
+  stateRoot,
+  home = homedir(),
+  env = process.env,
+  watch = recordWatchedRun,
+  terminate = terminateChild,
+} = {}) {
+  const launch = validateLaunch(options);
+  const invocation = buildInvocation(launch, { env, home });
+  return launchDetached({ invocation, prompt: launch.prompt, ...launch }, {
+    spawnImpl,
+    fs,
+    stateRoot: stateRoot ?? recoveryStateRoot(launch.devConfigPath),
+    watch,
+    terminate,
+  });
+}
+
+/**
+ * Launch a fresh recovery process after Dev has reserved its run.
+ *
+ * Files live outside the repository under stateRoot/<run-id>. The log is
+ * opened append-only and both files are private to the current user.
+ */
+export async function launchRecovery(payload, {
+  spawnImpl = spawn,
+  fs = fsPromises,
+  stateRoot,
+  home = homedir(),
+  env = process.env,
+  watch = recordWatchedRun,
+  terminate = terminateChild,
+} = {}) {
+  const data = dataFrom(payload);
+  const { runId, laneKey } = validateData(data);
+  const devConfigPath = absolutePath(data?.launch?.devConfigPath, "launch.devConfigPath");
+  const prompt = buildRecoveryPrompt(data);
+  const invocation = buildRecoveryInvocation(data, { env, home });
+  return launchDetached({ invocation, prompt, runId, laneKey, devConfigPath }, {
+    spawnImpl,
+    fs,
+    stateRoot: stateRoot ?? recoveryStateRoot(devConfigPath),
+    watch,
+    terminate,
+  });
+}

package/dist/safety.js

@@ -280,6 +280,18 @@ async function harnessGenerated(root) {
 }
 
 function laneOwnership(lane, root) {
+  const repository = lane?.repositories?.find((item) => {
+    const worktree = resolve(item.worktree);
+    return worktree === root;
+  });
+  if (repository) {
+    const paths = repository.ownedPaths.map((item) => {
+      if (!isAbsolute(item)) return cleanPath(item);
+      const rel = cleanPath(relative(root, item));
+      return rel.startsWith("../") ? item : rel;
+    });
+    return { known: true, paths };
+  }
   const direct = lane && Object.hasOwn(lane, "ownedPaths");
   const frozen = lane?.freeze?.boundaries && Object.hasOwn(lane.freeze.boundaries, "ownedPaths");
   const candidates = direct ? lane.ownedPaths : frozen ? lane.freeze.boundaries.ownedPaths : [];
@@ -298,6 +310,13 @@ async function currentLane(cwd, request, config) {
   const branch = await git(cwd, "branch", "--show-current");
   const rootText = await git(cwd, "rev-parse", "--show-toplevel");
   const root = await realpath(rootText).catch(() => resolve(rootText));
+  const markerText = await optional(await gitPrivatePath(cwd, "nodii-lane.json"));
+  if (markerText) {
+    const marker = JSON.parse(markerText);
+    const lane = (await request("GET", `/api/v1/lanes/${encode(marker.laneKey)}`)).data;
+    const repository = lane.repositories?.find((item) => item.branch === branch && resolve(item.worktree) === root);
+    if (lane.agentId === config.agentId && repository && ACTIVE.has(lane.status)) return lane;
+  }
   const lanes = (await request("GET", "/api/v1/lanes?limit=200")).data ?? [];
   for (const lane of lanes) {
     if (lane.agentId !== config.agentId || lane.branch !== branch || !ACTIVE.has(lane.status)) continue;

package/dist/setup.js

@@ -17,8 +17,8 @@ description: Drive every Nodii build lane through nodii-dev from start to verifi
 
 Use \`nodii-dev\` as the control plane. It talks only to Dev, through the platform edge, signed in with \`nodii-dev login\` as the platform tenant's OAuth app. The canonical policy is the build-workflow rulebook in Dev (\`nodii-dev rulebook list\`), §§1–8 (operator rulings A-020/A-021). Never change lane state in Dev by another route.
 
-1. Start: \`nodii-dev lane start KEY --title "..." --kind dev_fix|new_build|docs_change|uat_fix|prod_fix --side backend|frontend|both [--issue ISSUE]\`.
-2. Ask \`nodii-dev next KEY\`; start, complete, or block the reported API step with \`nodii-dev lane step\`.
+1. The machine coordinator runs \`nodii-dev coordinator start --machine NAME\`, then \`nodii-dev lane launch KEY\` with the issue (whose title is the objective), done check, build kind/side, repeated repository/branch pairs, runtime profile/model and subagent quota. A launched agent begins with \`nodii-dev lane gather\` from its worktree.
+2. Re-run \`nodii-dev lane gather\` for the current steps and rules; start, complete, or block the reported API step with \`nodii-dev lane step\`. After an authoritative \`lane amend\`, every run is blocked until its own \`lane gather --delta\` acknowledgement.
 3. Record durable evidence with \`nodii-dev lane evidence KEY --pr|--commit|--figma|--deploy|--dev-check REF\` and heartbeat long-running work with \`nodii-dev lane heartbeat KEY --note "..."\` (notes are at most 500 characters).
 4. Record the review gate with \`nodii-dev lane review KEY\`. After merge, run \`nodii-dev lane land KEY\`. Done still means deployed and checked live on dev as the right user: \`nodii-dev lane verify KEY --dev-check REF\`.
 5. Use \`nodii-dev lane prioritize|deprioritize KEY --reason "..."\` when priority changes; the reason is required. The lane stays on Built until a staff login runs \`nodii-dev built ack KEY\`. Never treat acknowledgement as testing.