automata-cli 0.11.0-develop.462 → 0.11.0-develop.468

package/README.md

@@ -133,6 +133,12 @@ One tick of the autonomous loop: answer the open issues whose newest message fro
 
 ---
 
+## `automata conductor`
+
+One cron-friendly tick of the conductor role, run as an allowed (human) account with its own run lock beside `do-work`'s. Reference: [docs/conductor.md](docs/conductor.md).
+
+---
+
 ## Development
 
 ### Prerequisites

package/dist/index.js

@@ -14,7 +14,7 @@ import {
 } from "./chunk-DTZB5FOY.js";
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -3581,6 +3581,19 @@ function identityProblemFor(login2, agentUser, allowedUsers) {
   }
   return `\`gh\` is authenticated as "${login2}" but agentUser is "${agentUser}". Comments posted under that identity are neither the agent's nor an authorized user's, so they are filtered out of the conversation: the answer boundary would never advance and the same message would start a run on every tick. Authenticate \`gh\` as the agent account (${agentUser}) in this environment, or correct \`agentUser\`.`;
 }
+function conductorIdentityProblemFor(login2, agentUser, allowedUsers) {
+  if (login2 === null) {
+    return "Could not determine which account `gh` is authenticated as, and the conductor must run as an account listed in allowedUsers. Run `gh auth login` as that account, or set `GH_TOKEN` in the scheduler's environment.";
+  }
+  const lower = login2.toLowerCase();
+  if (lower === agentUser.toLowerCase()) {
+    return `\`gh\` is authenticated as "${login2}", which is the agent (agentUser). The conductor instructs the agent and must run as a different account listed in allowedUsers.`;
+  }
+  if (!allowedUsers.some((user) => user.toLowerCase() === lower)) {
+    return `\`gh\` is authenticated as "${login2}", which is not listed in allowedUsers. Authenticate \`gh\` as one of the allowed users, or add this account to allowedUsers.`;
+  }
+  return null;
+}
 
 // src/github/workDetection.ts
 var NO_ISSUE_MESSAGES = {
@@ -4137,12 +4150,15 @@ function readHeartbeat(token, cwd = process.cwd()) {
 var LOCK_DIR = ".automata";
 var LOCK_FILE = "automata.lock";
 var RUN_LOCK_RELATIVE_PATH = `${LOCK_DIR}/${LOCK_FILE}`;
+var CONDUCTOR_LOCK_FILE = "conductor.lock";
+var CONDUCTOR_LOCK_RELATIVE_PATH = `${LOCK_DIR}/${CONDUCTOR_LOCK_FILE}`;
 var AUTOMATA_OWN_PATHS = [
   RUN_LOCK_RELATIVE_PATH,
+  CONDUCTOR_LOCK_RELATIVE_PATH,
   HEARTBEAT_RELATIVE_PATH
 ];
-function lockPath() {
-  return join4(process.cwd(), LOCK_DIR, LOCK_FILE);
+function lockPath(lockFile = LOCK_FILE) {
+  return join4(process.cwd(), LOCK_DIR, lockFile);
 }
 function processStartedAt(pid) {
   try {
@@ -4278,8 +4294,8 @@ function publishLock(path, command, token) {
     }
   }
 }
-function acquireRunLock(command, staleMinutes) {
-  const path = lockPath();
+function acquireRunLock(command, staleMinutes, lockFile = LOCK_FILE) {
+  const path = lockPath(lockFile);
   const token = randomUUID();
   mkdirSync(join4(process.cwd(), LOCK_DIR), { recursive: true });
   if (publishLock(path, command, token)) {
@@ -4299,6 +4315,9 @@ var UNKNOWN_OWNER = {
   command: "unknown",
   token: ""
 };
+function acquireConductorLock(staleMinutes) {
+  return acquireRunLock("conductor", staleMinutes, CONDUCTOR_LOCK_FILE);
+}
 function claimStaleLock(path, token, expected) {
   const claimed = `${path}.stale.${token}`;
   try {
@@ -8063,8 +8082,84 @@ function toPlanJson(decision) {
   };
 }
 
+// src/commands/conductor.ts
+import { Command as Command7 } from "commander";
+function fail2(message) {
+  process.stderr.write(`Error: ${message}
+`);
+  return 1;
+}
+function runConductor() {
+  let config;
+  try {
+    config = readConfig();
+  } catch (err) {
+    return fail2(err.message);
+  }
+  if (!isExplicitGitHub(config)) {
+    return fail2(
+      azdoUnsupportedMessage(
+        "conductor",
+        "It needs the GitHub APIs; set the remote with `automata config set type gh`."
+      )
+    );
+  }
+  const allowedUsers = (config.allowedUsers ?? []).filter((user) => user.trim().length > 0);
+  if (allowedUsers.length === 0) {
+    return fail2("No allowed users configured. Run `automata config set allowed-users <user1,user2>`.");
+  }
+  const agentUser = (config.agentUser ?? "").trim();
+  if (agentUser.length === 0) {
+    return fail2("No agent user configured. Run `automata config set agent-user <login>`.");
+  }
+  let login2;
+  try {
+    login2 = getAuthenticatedLogin();
+  } catch (err) {
+    return fail2(`\`gh\` could not be queried: ${err.message}`);
+  }
+  const problem = conductorIdentityProblemFor(login2, agentUser, allowedUsers);
+  if (problem !== null) return fail2(problem);
+  const rawStale = config.doWork?.lockStaleMinutes;
+  if (rawStale !== void 0 && rawStale !== null) {
+    if (typeof rawStale !== "number" || !Number.isSafeInteger(rawStale) || rawStale < 1) {
+      return fail2(`doWork.lockStaleMinutes must be a positive integer, got ${JSON.stringify(rawStale)}.`);
+    }
+  }
+  const staleMinutes = config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
+  const lock = acquireConductorLock(staleMinutes);
+  if (!lock.ok) {
+    const held = lock.heldBy;
+    process.stdout.write(
+      `Another conductor is already running here (pid ${String(held.pid)} on ${held.host}, started ${held.startedAt}). Doing nothing.
+`
+    );
+    if (lock.suspect) {
+      process.stderr.write(
+        `Warning: that lock has been held longer than ${String(staleMinutes)} minutes. If no tick is really running, its process id was probably reused; remove ${CONDUCTOR_LOCK_RELATIVE_PATH} once you have confirmed that.
+`
+      );
+      return 2;
+    }
+    return 0;
+  }
+  try {
+    process.stdout.write(`Conductor: running as ${login2 ?? ""}. Nothing to do yet.
+`);
+    return 0;
+  } finally {
+    lock.handle.release();
+  }
+}
+var conductorCommand = new Command7("conductor").description(
+  "Run one conductor tick as an allowed (human) account: verify the identity, take the conductor's own run lock, then act"
+).action(() => {
+  const exitCode = runConductor();
+  if (exitCode !== 0) process.exit(exitCode);
+});
+
 // src/index.ts
-var program = new Command7();
+var program = new Command8();
 program.name("automata").description("Automata CLI tool").version(version, "-v, --version");
 program.addCommand(configCommand);
 program.addCommand(gitCommand2);
@@ -8072,6 +8167,7 @@ program.addCommand(implementNextCommand);
 program.addCommand(executeCommand);
 program.addCommand(executePromptCommand);
 program.addCommand(doWorkCommand);
+program.addCommand(conductorCommand);
 program.showHelpAfterError();
 program.parse();
 if (process.argv.length <= 2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.11.0-develop.462",
+  "version": "0.11.0-develop.468",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {