@awebai/oats 0.29.3 → 0.29.4

package/lib/triggers.mjs

@@ -28,8 +28,8 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readDefinitions, writeDefinitions, stateDir, withScopeLock, childEnv, parseEnvelopeText, schedulerStatus } from "./schedule.mjs";
-import { automationError, baseRow, localEntry, localId, qualifiedId, soulOriginOf } from "./automations.mjs";
+import { readDefinitions, writeDefinitions, stateDir, withScopeLock, childEnv, parseEnvelopeText, schedulerStatus, readRegistry } from "./schedule.mjs";
+import { MODEL_RE, automationError, baseRow, localEntry, localId, parseOwner, qualifiedId, soulOriginOf } from "./automations.mjs";
 import { lockedPackageRef } from "./packages.mjs";
 
 export const TRIGGER_API = 1;
@@ -121,7 +121,7 @@ export function validateTrigger(def) {
   if (!Array.isArray(teams) || teams.some((t) => typeof t !== "string" || !LABEL_RE.test(t)) || new Set(teams).size !== teams.length) throw invalid("spawn.teams", "a list of distinct team labels");
   if (sp.launchConfig !== undefined && (typeof sp.launchConfig !== "string" || !LAUNCH_CONFIG_RE.test(sp.launchConfig))) throw invalid("spawn.launchConfig", "the name of a launch configuration on the running host (oats-local.yaml launch-configs)");
   if (sp.harness !== undefined && !HARNESSES.has(sp.harness)) throw invalid("spawn.harness", "pi, claude or codex");
-  if (sp.model !== undefined && (typeof sp.model !== "string" || !sp.model.trim())) throw invalid("spawn.model", "a model id");
+  if (sp.model !== undefined && (typeof sp.model !== "string" || !MODEL_RE.test(sp.model))) throw invalid("spawn.model", "a model id: a letter or digit, then letters, digits and . _ : / @ + - [ ] (at most 128 characters)");
   if (sp.yolo !== undefined && typeof sp.yolo !== "boolean") throw invalid("spawn.yolo", "boolean");
   if (sp.backend !== undefined && !BACKENDS.has(sp.backend)) throw invalid("spawn.backend", "tmux or herdr");
   const cc = def.concurrency === undefined ? {} : def.concurrency;
@@ -207,7 +207,12 @@ export function triggerKind({ lock = null, remote = null } = {}) {
     parseBody: parseTriggerBody,
     expand: async (a) => {
       const raw = a.source.from ? await packageTriggerTemplate(lock, a.source.from, a.source.set, { id: a.name, remote }) : { ...a.source.definition };
-      return validateTrigger({ ...raw, id: a.name, kind: "trigger", enabled: true });
+      const def = validateTrigger({ ...raw, id: a.name, kind: "trigger", enabled: true });
+      // The owner check asks gh on the OWNER's host, and the poll runs on the REPO's host: they must be
+      // one GitHub host, or polling would act as whoever is logged in there (re-review B #7).
+      const owner = parseOwner(a.owner), repo = parseRepo(def.on.repo);
+      if (owner && repo && owner.host.toLowerCase() !== repo.host) throw Object.assign(triggerError("E_TRIGGER_INVALID", `owner ${a.owner} is on ${owner.host}, but on.repo ${repo.key} is on ${repo.host}: a trigger acts as its owner on the repository's own GitHub host`), { field: "owner" });
+      return def;
     },
   };
 }
@@ -265,8 +270,28 @@ export function readTriggerState(ws) {
   let doc;
   try { doc = JSON.parse(readFileSync(file, "utf8")); } catch { doc = null; }
   if (!isObject(doc) || !isObject(doc.triggers)) return { version: 1, triggers: {} };
+  return carryUnqualifiedState(doc);
+}
+/** 0.28 kept a local trigger's state under its bare id, with event keys `<id>:…`; 0.29 qualifies
+ *  both as `local/<id>`. Carried on read (re-review B #2): without it the first 0.29 tick saw no
+ *  PR state, so every open matching PR emitted `opened` and spawned again. A bare id already
+ *  present in qualified form keeps the qualified state. */
+function carryUnqualifiedState(doc) {
+  for (const id of Object.keys(doc.triggers)) {
+    if (id.includes("/")) continue;
+    const qid = localId(id), old = doc.triggers[id];
+    delete doc.triggers[id];
+    if (doc.triggers[qid] || !isObject(old)) continue;
+    const rekey = (map) => Object.fromEntries(Object.entries(isObject(map) ? map : {}).map(([k, v]) => {
+      const key = k.startsWith(`${id}:`) ? `${qid}${k.slice(id.length)}` : k;
+      return [key, isObject(v) && "key" in v ? { ...v, key, ...(v.trigger === id ? { trigger: qid } : {}) } : v];
+    }));
+    doc.triggers[qid] = { ...old, prs: isObject(old.prs) ? old.prs : {}, fired: rekey(old.fired), pending: rekey(old.pending) };
+  }
   return doc;
 }
+/** Whether an instance's recorded trigger id is `id`: a 0.28 home records a local trigger's bare id. */
+const sameTrigger = (recorded, id) => recorded === id || (typeof recorded === "string" && !recorded.includes("/") && id === localId(recorded));
 function writeTriggerState(ws, st) {
   const file = statePath(ws);
   mkdirSync(dirname(file), { recursive: true });
@@ -290,7 +315,7 @@ export function liveTriggerInstances(ws, id) {
       if (!e.isDirectory()) continue;
       const home = join(instances, e.name);
       let meta; try { meta = JSON.parse(readFileSync(join(home, "instance.json"), "utf8")); } catch { continue; }
-      if (isObject(meta?.trigger) && meta.trigger.id === id) out.push({ instance: meta.instance ?? e.name, home, repo: meta.trigger.repo, number: meta.trigger.number, event: meta.trigger.event, key: meta.trigger.key ?? null });
+      if (isObject(meta?.trigger) && (id === null || sameTrigger(meta.trigger.id, id))) out.push({ instance: meta.instance ?? e.name, home, repo: meta.trigger.repo, number: meta.trigger.number, event: meta.trigger.event, key: meta.trigger.key ?? null });
     }
   }
   return out;
@@ -359,6 +384,9 @@ export function foldPoll(def, ts, poll, now) {
     for (const e of eventsFor(def, ts.prs[pr.number], pr)) {
       const key = eventKey(def, pr, e);
       if (ts.fired[key] || ts.pending[key]) continue;
+      // A newer push supersedes a pending `synchronize` for an older head of the same PR: only
+      // the newest head is reviewed (re-review B #6).
+      if (e.event === "synchronize") for (const [k, p] of Object.entries(ts.pending)) if (p.number === pr.number && p.event === "synchronize") delete ts.pending[k];
       ts.pending[key] = { trigger: def.qid ?? def.id, source: def.on.source, repo: def.on.repo, number: pr.number, url: pr.url, event: e.event, headSha: pr.headSha, labels: pr.labels, observedAt: now.toISOString(), key };
       added.push(key);
     }
@@ -384,7 +412,7 @@ function runOats(ws, argv, io) {
 /** What `oats spawn <soul> --preview` says about the soul: its qualified resolution and the
  *  capability filling its messaging slot. → { ok, result | error } */
 export function previewSoul(ws, def, io) {
-  const r = runOats(ws, ["spawn", def.spawn.soul, "--dir", ws, "--preview", "--json"], io);
+  const r = runOats(ws, ["spawn", def.spawn.soul, `--dir=${ws}`, "--preview", "--json"], io);
   if (!r.envelope || typeof r.envelope.ok !== "boolean") return { ok: false, error: { code: "E_SPAWN_FAILED", message: r.timedOut ? "spawn --preview timed out" : `spawn --preview answered no envelope${r.stderr ? `: ${r.stderr.trim().split("\n").pop()}` : ""}` } };
   if (!r.envelope.ok) return { ok: false, error: { code: r.envelope.error?.code ?? "E_SPAWN_FAILED", message: r.envelope.error?.message ?? "spawn --preview failed" } };
   const modules = Array.isArray(r.envelope.result?.modules) ? r.envelope.result.modules : [];
@@ -396,17 +424,18 @@ export function previewSoul(ws, def, io) {
 export function spawnForEvent(ws, def, ev, io) {
   const fields = { repo: ev.repo, number: ev.number, url: ev.url, event: ev.event, headSha: ev.headSha, trigger: def.id };
   const purpose = renderTemplate(def.spawn.purpose, fields);
-  const argv = ["spawn", def.spawn.soul, "--dir", ws, "--purpose", purpose, "--json"];
+  // Every value travels as ONE `--flag=value` token, so no value can be read as a flag of its own.
+  const argv = ["spawn", def.spawn.soul, `--dir=${ws}`, `--purpose=${purpose}`, "--json"];
   if (def.spawn.teams.length) {
     const pv = previewSoul(ws, def, io);
     if (!pv.ok) throw triggerError(pv.error.code, pv.error.message);
     if (!pv.messaging) throw triggerError("E_TRIGGER_TEAMS", `trigger ${def.id}: spawn.teams [${def.spawn.teams.join(", ")}] needs a messaging capability, and soul ${def.spawn.soul} resolves none`, { details: { soul: def.spawn.soul, teams: def.spawn.teams } });
     argv.push("--provider", pv.messaging, `join=${def.spawn.teams.join(",")}`);
   }
-  if (def.spawn.launchConfig) argv.push("--launch-config", def.spawn.launchConfig);
-  if (def.spawn.harness) argv.push("--harness", def.spawn.harness);
-  if (def.spawn.model) argv.push("--model", def.spawn.model);
-  if (def.spawn.backend) argv.push("--backend", def.spawn.backend);
+  if (def.spawn.launchConfig) argv.push(`--launch-config=${def.spawn.launchConfig}`);
+  if (def.spawn.harness) argv.push(`--harness=${def.spawn.harness}`);
+  if (def.spawn.model) argv.push(`--model=${def.spawn.model}`);
+  if (def.spawn.backend) argv.push(`--backend=${def.spawn.backend}`);
   if (def.spawn.yolo === true) argv.push("--yolo"); else if (def.spawn.yolo === false) argv.push("--no-yolo");
   if (io?.noLaunch === true) argv.push("--no-launch");
   // The task and the event travel as private files, never in argv.
@@ -416,7 +445,7 @@ export function spawnForEvent(ws, def, ev, io) {
   const taskFile = `${stem}.md`, eventFile = `${stem}.event.json`;
   writeFileSync(eventFile, JSON.stringify(ev, null, 2) + "\n", { mode: 0o600 });
   writeFileSync(taskFile, renderTemplate(def.spawn.task, fields).trimEnd() + triggerBlock(def, ev, "<home>/.oats/trigger-event.json"), { mode: 0o600 });
-  argv.push("--task-file", taskFile, "--trigger-event", eventFile);
+  argv.push(`--task-file=${taskFile}`, `--trigger-event=${eventFile}`);
   let r;
   try { r = runOats(ws, argv, io); }
   finally { for (const f of [taskFile, eventFile]) { try { rmSync(f, { force: true }); } catch { /* best effort */ } } }
@@ -438,10 +467,16 @@ function heldBy(def, ev, live) {
  *  whose poll is not due is not polled; pending events (a spawn that failed, or was held by
  *  concurrency) are retried whenever the trigger polls. `dryRun` reads only.
  *  → considered rows { workspace, trigger, action, … } */
-export function tickTriggers(ws, { now = new Date(), io, dryRun = false, ctx = null } = {}) {
+export function tickTriggers(ws, { now = new Date(), io, dryRun = false, ctx = null, reg = null, wsList = null } = {}) {
   let entries;
   try { entries = triggerEntries(ws, ctx); } catch (e) { return [{ workspace: ws, action: "error", error: e.message }]; }
   if (!entries.length) return [];
+  // The host cap (registry triggersMaxConcurrent; absent = unbounded) counts every trigger-spawned
+  // live home in the host's scopes, and nothing a schedule runs (re-review B #5).
+  let hostCap;
+  try { hostCap = (reg || readRegistry()).triggersMaxConcurrent; } catch (e) { return [{ workspace: ws, action: "error", error: e.message }]; }
+  const scopes = [...new Set([...(wsList || []), ws])];
+  let hostLive = hostCap ? scopes.reduce((n, w) => n + liveTriggerInstances(w, null).length, 0) : 0;
   const st = readTriggerState(ws);
   const considered = [];
   const rec = (id, action, extra = {}) => considered.push({ workspace: ws, trigger: id, action, ...extra });
@@ -471,15 +506,16 @@ export function tickTriggers(ws, { now = new Date(), io, dryRun = false, ctx = n
     const queue = Object.values(work.pending).sort((a, b) => a.observedAt.localeCompare(b.observedAt) || a.key.localeCompare(b.key));
     if (!queue.length) rec(id, "polled", { prs: work.lastPoll.prs, matching: work.lastPoll.matching });
     for (const ev of queue) {
-      const held = heldBy(def, ev, live);
+      const held = heldBy(def, ev, live) ?? (hostCap && hostLive >= hostCap ? `host triggersMaxConcurrent ${hostCap} reached (${hostLive} live)` : null);
       if (held) { rec(id, "held", { key: ev.key, reason: held }); continue; }
-      if (dryRun) { rec(id, "would-fire", { key: ev.key, event: ev.event, number: ev.number, url: ev.url }); live.push({ repo: ev.repo, number: ev.number }); continue; }
+      if (dryRun) { rec(id, "would-fire", { key: ev.key, event: ev.event, number: ev.number, url: ev.url }); live.push({ repo: ev.repo, number: ev.number }); hostLive++; continue; }
       try {
         const run = spawnForEvent(ws, def, ev, io);
         work.fired[ev.key] = { at: now.toISOString(), instance: run.instance ?? null, home: run.home ?? null, event: ev.event, number: ev.number };
         delete work.pending[ev.key];
         work.lastFiredAt = now.toISOString();
         live.push({ instance: run.instance, home: run.home, repo: ev.repo, number: ev.number });
+        hostLive++;
         rec(id, "fired", { key: ev.key, instance: run.instance ?? null, home: run.home ?? null });
       } catch (e) {
         work.lastError = { at: now.toISOString(), code: e.code || "E_SPAWN_FAILED", message: e.message, key: ev.key };

package/package-catalog.json

@@ -3,7 +3,7 @@
   "packages": {
     "oats.okf": {
       "url": "https://github.com/awebai/oats-okf.git",
-      "ref": "v4.0.0",
+      "ref": "v4.0.1",
       "path": "oats-package"
     },
     "oats.aweb": {
@@ -33,7 +33,7 @@
     },
     "oats.framework": {
       "url": "https://github.com/awebai/oats.git",
-      "ref": "oats-framework/v1.3.1",
+      "ref": "oats-framework/v1.3.2",
       "path": "oats-package"
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/oats",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "description": "OATS (Open Agent Team Specification) — durable souls, disposable instances, targetable capability packages, and the runtime-neutral oats CLI/kernel.",
   "keywords": [
     "agents",