@astrohacker/factory 0.1.0 → 0.2.0

package/dist/ahfact.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 
 // cli/ahfact.ts
-import { execFileSync } from "node:child_process";
-import { chmod, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readdir, readFile as readFile2, rm, writeFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { parseArgs } from "node:util";
 
 // node_modules/@orpc/shared/dist/index.mjs
@@ -1613,6 +1612,140 @@ function parseGitHubRemote(remote) {
   return `${owner}/${name}`;
 }
 
+// cli/github-read.ts
+import { execFile } from "node:child_process";
+var ISSUE_LIMIT = 300;
+var PR_LIMIT = 200;
+var ISSUE_FIELDS = "number,title,state,labels,url";
+var PR_FIELDS = "number,title,state,isDraft,headRefOid,headRefName,baseRefName,labels,closingIssuesReferences,author,url,mergeCommit";
+function mapIssue(i) {
+  return { number: i.number, title: i.title, state: i.state === "OPEN" ? "open" : "closed", labels: i.labels.map((l) => l.name), url: i.url };
+}
+function mapPullRequest(p, repo) {
+  const sameRepo = (url) => url === undefined || url.toLowerCase().startsWith(`https://github.com/${repo.toLowerCase()}/`);
+  return {
+    number: p.number,
+    title: p.title,
+    state: p.state === "MERGED" ? "merged" : p.state === "OPEN" ? "open" : "closed",
+    draft: p.isDraft,
+    headSha: p.headRefOid,
+    headRef: p.headRefName,
+    baseRef: p.baseRefName,
+    labels: p.labels.map((l) => l.name),
+    closingIssues: p.closingIssuesReferences.filter((r) => sameRepo(r.url)).map((r) => r.number),
+    author: p.author?.login ?? "",
+    url: p.url,
+    mergeCommit: p.mergeCommit?.oid ?? null
+  };
+}
+function gh(args) {
+  return new Promise((resolve, reject) => {
+    execFile("gh", args, { maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error)
+        reject(new Error(`gh ${args.slice(0, 2).join(" ")} failed: ${(stderr || error.message).trim()}`));
+      else
+        resolve(stdout);
+    });
+  });
+}
+async function readGitHub(repo) {
+  const [issues, prs] = await Promise.all([
+    gh(["issue", "list", "--repo", repo, "--state", "all", "--limit", String(ISSUE_LIMIT), "--json", ISSUE_FIELDS]),
+    gh(["pr", "list", "--repo", repo, "--state", "all", "--limit", String(PR_LIMIT), "--json", PR_FIELDS])
+  ]);
+  return {
+    issues: JSON.parse(issues).map(mapIssue),
+    pullRequests: JSON.parse(prs).map((p) => mapPullRequest(p, repo))
+  };
+}
+
+// cli/repo.ts
+import { execFileSync, spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var HOOKS = ["setup", "check", "deploy"];
+
+class ConfigError extends Error {
+}
+function repoRoot(cwd = process.cwd()) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function checkoutRepo(cwd = process.cwd()) {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return parseGitHubRemote(url);
+  } catch {
+    return null;
+  }
+}
+function parseRepoConfig(text, file = ".ahfact.json") {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new ConfigError(`${file} is not valid JSON: ${error.message}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    throw new ConfigError(`${file} must be a JSON object.`);
+  const obj = raw;
+  const config = { hooks: {} };
+  if (obj["project"] !== undefined) {
+    if (typeof obj["project"] !== "string")
+      throw new ConfigError(`${file}: "project" must be a string.`);
+    config.project = obj["project"];
+  }
+  const hooks = obj["hooks"] ?? {};
+  if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks))
+    throw new ConfigError(`${file}: "hooks" must be an object.`);
+  for (const [name, command] of Object.entries(hooks)) {
+    if (!HOOKS.includes(name)) {
+      throw new ConfigError(`${file}: unknown hook "${name}". Known hooks: ${HOOKS.join(", ")}.`);
+    }
+    if (typeof command !== "string" || command.trim() === "")
+      throw new ConfigError(`${file}: hook "${name}" must be a command string.`);
+    config.hooks[name] = command;
+  }
+  return config;
+}
+async function loadRepoConfig(root) {
+  const file = join(root, ".ahfact.json");
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch {
+    return { hooks: {} };
+  }
+  return parseRepoConfig(text, file);
+}
+var TAIL_LINES = 40;
+function runHook(root, hook, command, env = {}) {
+  const started = Date.now();
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", command], { cwd: root, env: { ...process.env, ...env }, stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    const collect = (chunk) => {
+      process.stderr.write(chunk);
+      output = (output + chunk.toString("utf8")).slice(-64000);
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      const tail = output.trimEnd().split(`
+`).slice(-TAIL_LINES).join(`
+`);
+      resolve({ hook, command, ok: exitCode === 0, exitCode, durationMs: Date.now() - started, tail });
+    });
+    child.on("error", (error) => {
+      resolve({ hook, command, ok: false, exitCode: 127, durationMs: Date.now() - started, tail: error.message });
+    });
+  });
+}
+
 // cli/ahfact.ts
 var DEFAULT_SERVER = "https://ahfact.com";
 var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
@@ -1633,11 +1766,18 @@ Workers (one per project, harness and computer):
   ahfact worker start --harness H [--machine M]
                                        create or reuse this checkout's worker and save its token
   ahfact worker whoami                 the worker this checkout's commands act as
-  ahfact wait [--timeout SECONDS]      lease the next job, waiting until one comes (or the timeout)
+  ahfact sync [--force]                read this project's GitHub issues and PRs with gh and report them;
+                                       ahfact.com turns them into jobs (one worker at a time, every 60s)
+  ahfact wait [--timeout SECONDS] [--no-sync]
+                                       sync when due, then lease the next job; repeat until one comes
   ahfact next [--wait SECONDS]         one attempt, waiting at most 55 seconds; prints null if none
   ahfact leases                        the worker's live leases, to resume after a restart
   ahfact heartbeat                     say "still here"
 
+This checkout (hooks from .ahfact.json):
+  ahfact setup                         run the setup hook, such as installing dependencies
+  ahfact check                         run the check hook; prints {ok, exitCode, durationMs, tail}
+
 Jobs:
   ahfact job create --kind K --subject S --title T [--harness H] [--machine M] [--exclude AGENT]...
 
@@ -1658,26 +1798,26 @@ Credentials live in ~/.config/ahfact/, mode 0600.`;
 class UsageError extends Error {
 }
 function configDir() {
-  return join(process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config"), "ahfact");
+  return join2(process.env["XDG_CONFIG_HOME"] ?? join2(homedir(), ".config"), "ahfact");
 }
 function hostOf(server) {
   return new URL(server).host.replace(/[^A-Za-z0-9.-]/g, "_");
 }
 async function writePrivate(file, value) {
-  await mkdir(join(file, ".."), { recursive: true, mode: 448 });
+  await mkdir(join2(file, ".."), { recursive: true, mode: 448 });
   await writeFile(file, JSON.stringify(value, null, 2) + `
 `, { mode: 384 });
   await chmod(file, 384);
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile(file, "utf8"));
+    return JSON.parse(await readFile2(file, "utf8"));
   } catch {
     return null;
   }
 }
-var personFile = (server) => join(configDir(), "people", `${hostOf(server)}.json`);
-var workerFile = (worker) => join(configDir(), "workers", `${worker}.json`);
+var personFile = (server) => join2(configDir(), "people", `${hostOf(server)}.json`);
+var workerFile = (worker) => join2(configDir(), "workers", `${worker}.json`);
 async function loadPerson(server) {
   const cred = await readJson(personFile(server));
   if (cred === null || cred.server !== server)
@@ -1687,24 +1827,16 @@ async function loadPerson(server) {
 async function allWorkers(server) {
   let files = [];
   try {
-    files = (await readdir(join(configDir(), "workers"))).filter((f) => f.endsWith(".json"));
+    files = (await readdir(join2(configDir(), "workers"))).filter((f) => f.endsWith(".json"));
   } catch {}
   const creds = [];
   for (const f of files) {
-    const cred = await readJson(join(configDir(), "workers", f));
+    const cred = await readJson(join2(configDir(), "workers", f));
     if (cred !== null && cred.server === server)
       creds.push(cred);
   }
   return creds;
 }
-function checkoutRepo() {
-  try {
-    const url = execFileSync("git", ["remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
-    return parseGitHubRemote(url);
-  } catch {
-    return null;
-  }
-}
 function requireRepo(explicit) {
   if (explicit) {
     const repo = parseGitHubRemote(explicit) ?? (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(explicit) ? explicit : null);
@@ -1803,6 +1935,8 @@ async function main(argv) {
       subject: { type: "string" },
       title: { type: "string" },
       exclude: { type: "string", multiple: true },
+      force: { type: "boolean" },
+      "no-sync": { type: "boolean" },
       help: { type: "boolean", short: "h" }
     }
   });
@@ -1813,7 +1947,17 @@ async function main(argv) {
   }
   const server = (str(values, "server") ?? process.env["AHFACT_URL"] ?? DEFAULT_SERVER).replace(/\/+$/, "");
   const asPerson = async () => client(server, (await loadPerson(server)).token);
-  const asWorker = async () => client(server, (await loadWorker(server, { worker: values.worker, harness: values.harness })).token);
+  const workerCred = () => loadWorker(server, { worker: values.worker, harness: values.harness });
+  const asWorker = async () => client(server, (await workerCred()).token);
+  const syncOnce = async (cred, force) => {
+    const api = client(server, cred.token);
+    const turn = await api.worker.syncBegin({ force });
+    if (!turn.due)
+      return { synced: false, ...turn };
+    const seen = await readGitHub(cred.repo);
+    const result = await api.worker.syncReport(seen);
+    return { synced: true, ...result };
+  };
   const leaseArgs = [sub, ...rest];
   const leaseId = () => {
     const id = leaseArgs[0];
@@ -1835,6 +1979,23 @@ async function main(argv) {
       }
       return print({ signedOut: cred !== null, server });
     }
+    case "setup":
+    case "check": {
+      const root = repoRoot();
+      if (root === null)
+        throw new UsageError(`${command} runs in a Git checkout.`);
+      const config = await loadRepoConfig(root);
+      const hook = command;
+      const script = config.hooks[hook];
+      if (!script)
+        throw new UsageError(`${root}/.ahfact.json has no "${hook}" hook.`);
+      hint(`ahfact ${hook}: ${script}`);
+      const result = await runHook(root, hook, script);
+      print(result);
+      if (!result.ok)
+        process.exit(1);
+      return;
+    }
     case "whoami": {
       const cred = await readJson(personFile(server));
       const person = cred === null ? null : await client(server, cred.token).auth.me().catch(() => null);
@@ -1876,11 +2037,26 @@ async function main(argv) {
       return print(await (await asWorker()).worker.leases());
     case "next":
       return print(await (await asWorker()).worker.next({ wait: Number(values.wait ?? 0) }));
+    case "sync": {
+      const cred = await workerCred();
+      return print(await syncOnce(cred, values.force === true));
+    }
     case "wait": {
-      const api = await asWorker();
+      const cred = await workerCred();
+      const api = client(server, cred.token);
       const timeout = values.timeout === undefined ? Infinity : Number(values.timeout) * 1000;
       const deadline = Date.now() + timeout;
       for (;; ) {
+        if (!values["no-sync"]) {
+          try {
+            const result = await syncOnce(cred, false);
+            if (result.synced && result.applied.length > 0) {
+              hint(`ahfact: synced GitHub: ${result.applied.map((a) => `${a.type} ${a.subject}`).join(", ")}`);
+            }
+          } catch (error) {
+            hint(`ahfact: sync failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
         const left = Math.ceil((deadline - Date.now()) / 1000);
         const claim = await api.worker.next({ wait: Math.max(0, Math.min(55, left)) });
         if (claim !== null)
@@ -1930,7 +2106,7 @@ async function main(argv) {
 try {
   await main(process.argv.slice(2));
 } catch (error) {
-  if (error instanceof UsageError) {
+  if (error instanceof UsageError || error instanceof ConfigError) {
     hint(`ahfact: ${error.message}`);
     process.exit(2);
   }
@@ -1943,5 +2119,9 @@ try {
     hint(`ahfact: cannot reach the factory: ${error.message}`);
     process.exit(3);
   }
+  if (error instanceof Error && error.message.startsWith("gh ")) {
+    hint(`ahfact: ${error.message}`);
+    process.exit(4);
+  }
   throw error;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrohacker/factory",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "ahfact: the command a worker and its subagents use to take and report on jobs in the Astrohacker Factory.",
   "type": "module",
   "bin": {