@nanocollective/roster 0.1.0-alpha.3 → 0.1.0-alpha.31

package/templates/portal/js/views/staff.js

@@ -1,44 +1,145 @@
-/* Hiring and retiring, from the portal.
+/* The Staff screen: a card per staff member, retiring, and the way in to hiring.
  *
- * Both run the CLI's own `buildPlan` and `applyPlan` on the server rather than describing
- * either again here. Two descriptions of how to create a repo is one too many, and the one in
- * the browser would be the one nobody updated.
- *
- * Plan then apply, the same as every roster command that changes something: you see every
- * file, every label and every existing staff member it would edit, and nothing happens until
- * you say so.
+ * Hiring itself is in hire.js. Retiring runs the CLI's own `buildRetirePlan` and
+ * `applyRetirePlan` on the server, plan then apply: you see what it stops and what it keeps,
+ * and nothing happens until you say so.
  */
 
 import { post } from "../api.js";
+import { askYes, sheet } from "../dialog.js";
+import { pending } from "../inflight.js";
 import { ago, el, esc } from "../dom.js";
-import { icon } from "../icons.js";
+import { whatsLeft, sentence } from "../readiness.js";
 import { refreshAll } from "../refresh.js";
 import { S } from "../state.js";
-import { appPanel } from "./app.js";
-import { paste } from "./paste.js";
+import { hireFlow, line, rolePicker } from "./hire.js";
+
+/**
+ * Resolves once nothing is loading and `node` has stopped changing for a moment, or after a few
+ * seconds regardless. Quiet alone was not enough: while GitHub was still answering, nothing
+ * changed, and the half-built list was shown.
+ */
+function settled(node, quiet = 250, most = 6000) {
+  return new Promise((resolve) => {
+    if (typeof MutationObserver !== "function") return resolve();
+    let lastChange = Date.now();
+    const obs = new MutationObserver(() => {
+      lastChange = Date.now();
+    });
+    obs.observe(node, { childList: true, subtree: true, attributes: true, characterData: true });
+    const started = Date.now();
+    const tick = setInterval(() => {
+      const now = Date.now();
+      if ((pending() === 0 && now - lastChange >= quiet) || now - started >= most) {
+        clearInterval(tick);
+        obs.disconnect();
+        resolve();
+      }
+    }, 50);
+  });
+}
 
-export function viewStaff(m) {
+/* The open dialog, if any. It lives on <body>, so it outlives a repaint of this screen, and a
+   background refresh leaves whatever was typed into it alone. */
+let current = null;
+
+/**
+ * @param {{open?: string, result?: object}} [o]  `open` keeps one staff member's steps on
+ *   screen across a repaint, which is how a finished hire lands on step 2.
+ */
+export function viewStaff(m, o = {}) {
   m.append(el("h1", { textContent: "Staff" }));
-  m.append(
-    el("p", {
-      className: "sub",
-      textContent:
-        S.data.staff.length +
-        " on the roster. Hiring creates a repo, its workflows, its labels and its pinned issue, " +
-        "and wires it to everyone already here.",
-    }),
-  );
+  const empty = !S.data.staff.length;
+  if (empty) m.append(el("p", { className: "sub", textContent: "No staff yet. Pick a role to hire your first." }));
 
-  const list = el("div", { className: "grid", style: "margin-bottom:18px" });
-  for (const s of S.data.staff) list.append(card(s));
-  m.append(list);
+  const pane = el("div", { className: "hirepane" });
 
-  const hire = el("button", { className: "ghbtn primary", textContent: "Hire someone" });
-  const pane = el("div");
-  hire.onclick = () => hireForm(pane);
-  m.append(el("div", { className: "row", style: "margin-bottom:14px" }, [hire]));
+  /* Tasks open in a dialog. Where there is no dialog element (the test shim) they draw into
+     the pane instead, which is how this screen always drew them. */
+  function present(node) {
+    const spin = el("div", { className: "sheetloading" }, [el("span", { className: "spinner" })]);
+    if (current?.isOpen()) current.set(spin);
+    else {
+      current = sheet({
+        node: spin,
+        onClose: () => {
+          current = null;
+          S.staffOpen = null;
+        },
+      });
+      if (!current) {
+        pane.replaceChildren(node);
+        return;
+      }
+    }
+    /* The list is built from half a dozen answers arriving one by one, and showing each as it
+       landed meant the dialog reflowed four times. It is shown once it has stopped changing. */
+    const mine = current;
+    settled(node).then(() => {
+      if (mine.isOpen() && current === mine) mine.set(node);
+    });
+  }
+  function dismiss() {
+    if (current) current.close();
+    else pane.replaceChildren();
+    S.staffOpen = null;
+    if (empty) pick();
+  }
+
+  // With nobody hired the roles are the page. After that they are a dialog behind Hire someone.
+  function pick() {
+    if (empty) {
+      pane.replaceChildren(rolePicker({ onPick: (role) => open(role) }));
+      return;
+    }
+    const cancel = el("button", { className: "ghbtn", textContent: "Cancel" });
+    cancel.onclick = dismiss;
+    present(
+      el("div", {}, [
+        el("h2", { className: "sheettitle", textContent: "Pick a role" }),
+        rolePicker({ onPick: (role) => open(role) }),
+        el("div", { className: "row", style: "margin-top:14px" }, [cancel]),
+      ]),
+    );
+  }
+
+  /* One staff member's steps, hired or not yet. A hire repaints the whole screen, so the new
+     card is in the list and the steps reopen on the same person. */
+  function open(role, result) {
+    // Remembered, so a refresh after a trip to GitHub (creating the App) reopens it.
+    S.staffOpen = role;
+    present(
+      hireFlow({
+        role,
+        result,
+        onHired: (handle, r) => {
+          m.replaceChildren();
+          viewStaff(m, { open: handle, result: r });
+        },
+        onClose: dismiss,
+      }),
+    );
+  }
+
+  if (!empty) {
+    const list = el("div", { className: "grid", style: "margin-bottom:18px" });
+    for (const s of S.data.staff) list.append(card(s));
+    // In the grid, where the next person would go, rather than a button under it.
+    const hire = el("button", { className: "hirecard", textContent: "Hire someone" });
+    hire.onclick = pick;
+    list.append(hire);
+    m.append(list);
+  }
   m.append(pane);
 
+  const opened = o.open && S.data.staff.find((s) => s.handle === o.open);
+  const kept = !opened && S.staffOpen;
+  const keptStaff = kept && S.data.staff.find((s) => s.handle === kept.handle);
+  if (empty) pick();
+  if (opened) open(roleOf(opened), o.result);
+  // An open dialog is still open; only the inline fallback has to be drawn again.
+  else if (kept && !current?.isOpen()) open(keptStaff ? roleOf(keptStaff) : kept);
+
   /* --------------------------- one staff member --------------------------- */
 
   function card(s) {
@@ -53,143 +154,32 @@ export function viewStaff(m) {
 
     const status = el("span", { className: "meta" });
     const go = el("button", { className: "ghbtn", textContent: "Retire" });
-    go.onclick = () => retireForm(pane, s, status);
-
-    /* The charter is the one file `hire` deliberately does not write, and until now the only
-       route to it was a CLI command printing a brief. This is the same brief, with every file
-       it refers to already inside it and somewhere to put the answer. */
-    const write = el("button", { className: "ghbtn", textContent: "Write the charter" });
-    write.onclick = () => {
-      pane.replaceChildren(
-        el("div", { className: "card" }, [
-          paste({
-            kind: "charter",
-            staff: s.handle,
-            title: "Write " + s.name + "'s charter with your own AI",
-            onSaved: () => refreshAll(false),
-          }),
-        ]),
-      );
-      pane.scrollIntoView?.({ behavior: "smooth", block: "start" });
+    go.onclick = () => {
+      const host = el("div");
+      present(host);
+      retireForm(host, s, status);
     };
 
-    /* The step `hire` has always had to hand back: there is no API that creates a GitHub App,
-       so it is a browser hand-off either way. It may as well be this browser. */
-    const app = el("button", { className: "ghbtn", textContent: "GitHub App" });
-    app.onclick = () => {
-      pane.replaceChildren(
-        el("div", { className: "card" }, [
-          el("h3", { textContent: s.name + "'s identity" }),
-          appPanel({ staff: s.handle, name: s.name, scope: "private" }),
-          appPanel({ staff: s.handle, name: s.name, scope: "public" }),
-        ]),
-      );
-      pane.scrollIntoView?.({ behavior: "smooth", block: "start" });
-    };
+    /* Every setup step (the App, the charter, the credential, a run) is in the one list, so the
+       card has one way in. It says Finish setting up until setup looks finished: the charter
+       from disk at once, and the App's secrets and a first run from GitHub when it answers. */
+    const finish = el("button", { className: "ghbtn", textContent: "Set up" });
+    finish.onclick = () => open(roleOf(s));
+    const warn = el("p", { className: "warnline", hidden: true });
+    whatsLeft(s).then((left) => {
+      if (!left.length) return;
+      finish.textContent = "Finish setting up";
+      finish.className = "ghbtn primary";
+      d.classList.add("notready");
+      warn.hidden = false;
+      warn.textContent = "Not ready to run. Still to do: " + sentence(left) + ".";
+    });
+    d.append(warn);
 
-    d.append(el("div", { className: "row", style: "margin-top:10px" }, [write, app, go, status]));
-    return d;
-  }
-
-  /* ------------------------------- hiring -------------------------------- */
-
-  function hireForm(host) {
-    const box = el("div", { className: "card" });
-    box.append(
-      el("h3", { textContent: "Hire someone" }),
-      el("p", {
-        className: "sub",
-        style: "margin-bottom:14px",
-        textContent:
-          "Only the handle is required. Everything else is copied from whoever is already " +
-          "here, because app slugs carry a house naming scheme and the public identity is " +
-          "genuinely shared.",
-      }),
+    d.append(
+      el("div", { className: "row", style: "margin-top:10px" }, [finish, go, status]),
     );
-
-    const handle = field("handle", "cfo", "lowercase, digits and dashes");
-    const name = field("name", "Chief Financial Officer", "defaults to the handle, uppercased");
-    const dir = field("dir", "finance", "directory and repo name; defaults to the handle");
-    const schedule = field("schedule", "0 9 * * 1-5", "defaults to a slot clear of everyone else");
-    for (const f of [handle, name, dir, schedule]) box.append(f.row);
-
-    const status = el("span", { className: "meta" });
-    const plan = el("button", { className: "ghbtn primary", textContent: "Show the plan" });
-    const cancel = el("button", { className: "ghbtn", textContent: "Cancel" });
-    cancel.onclick = () => host.replaceChildren();
-    box.append(el("div", { className: "row", style: "margin-top:12px" }, [plan, cancel, status]));
-
-    const out = el("div");
-    box.append(out);
-    host.replaceChildren(box);
-    handle.input.focus();
-
-    plan.onclick = async () => {
-      if (!handle.input.value.trim()) {
-        handle.input.focus();
-        return;
-      }
-      status.textContent = "planning…";
-      status.className = "meta";
-      out.replaceChildren();
-      const params = new URLSearchParams({ handle: handle.input.value.trim() });
-      for (const [key, f] of [["name", name], ["dir", dir], ["schedule", schedule]]) {
-        if (f.input.value.trim()) params.set(key, f.input.value.trim());
-      }
-      try {
-        const data = await (await fetch("/api/staff/plan?" + params, { cache: "no-store" })).json();
-        if (data.error) throw new Error(data.error);
-        status.textContent = "";
-        out.replaceChildren(hirePlan(data.plan, params));
-      } catch (e) {
-        status.textContent = e.message;
-        status.className = "meta err";
-      }
-    };
-  }
-
-  function hirePlan(plan, params) {
-    const box = el("div", { className: "plan" });
-    box.append(el("div", { className: "planhead", textContent: "This would create" }));
-
-    const s = plan.staff;
-    box.append(
-      line("ok", s.brain + ", private"),
-      line("ok", plan.files.length + " files, including three caller workflows"),
-      line("ok", plan.labels.length + " labels: " + plan.labels.join(", ")),
-      line("ok", "a pinned status issue"),
-      line("ok", "runs at " + s.schedule + ", on " + s.model),
-    );
-    for (const p of plan.peers) {
-      box.append(line("ok", p.dir + "/staff.yaml gains a peer entry and a " + p.label + " label"));
-    }
-    box.append(line("ok", "org.yaml gains a staff entry and a repo entry"));
-
-    if (plan.secrets?.length) {
-      box.append(el("div", { className: "planhead", textContent: "You will still have to" }));
-      box.append(
-        line("todo", "create the GitHub App: roster app " + s.handle),
-        line("todo", "put " + plan.secrets.join(", ") + " on the new repo"),
-      );
-    }
-    for (const w of plan.warnings ?? []) box.append(line("warn", w));
-
-    const status = el("span", { className: "meta" });
-    const go = el("button", { className: "ghbtn primary", textContent: "Hire " + s.handle });
-    go.onclick = () =>
-      apply(
-        {
-          action: "hire",
-          handle: s.handle,
-          flags: Object.fromEntries(params),
-        },
-        "Create " + s.brain + " and wire it up?\n\nThis creates a repository on GitHub.",
-        go,
-        status,
-        box,
-      );
-    box.append(el("div", { className: "row", style: "margin-top:14px" }, [go, status]));
-    return box;
+    return d;
   }
 
   /* ------------------------------- retiring ------------------------------- */
@@ -234,11 +224,11 @@ export function viewStaff(m) {
     const status = el("span", { className: "meta" });
     const go = el("button", { className: "ghbtn", textContent: "Retire " + plan.handle });
     const cancel = el("button", { className: "ghbtn", textContent: "Cancel" });
-    cancel.onclick = () => host.replaceChildren();
+    cancel.onclick = dismiss;
     go.onclick = () =>
       apply(
         { action: "retire", handle: plan.handle },
-        "Retire " + plan.name + "?\n\n" + (plan.brain ?? plan.dir) + " is not touched.",
+        { title: "Retire " + plan.name + "?", hint: (plan.brain ?? plan.dir) + " is not touched.", confirm: "Retire " + plan.handle },
         go,
         status,
         box,
@@ -250,7 +240,7 @@ export function viewStaff(m) {
   /* -------------------------------- apply -------------------------------- */
 
   async function apply(payload, ask, btn, status, box) {
-    if (!confirm(ask)) return;
+    if (!(await askYes(ask))) return;
     btn.disabled = true;
     status.textContent = "working…";
     status.className = "meta";
@@ -269,22 +259,7 @@ export function viewStaff(m) {
   }
 }
 
-function field(label, placeholder, hint) {
-  const input = el("input", { type: "search", placeholder, value: "", style: "width:100%" });
-  input.dataset.field = label;
-  const row = el("div", { className: "ffield" });
-  row.append(
-    el("label", { textContent: label }),
-    input,
-    el("small", { textContent: hint }),
-  );
-  return { row, input };
-}
-
-const MARK = { ok: "check", stop: "closed", keep: "issue-open", todo: "dash", warn: "label" };
-
-function line(kind, text) {
-  const d = el("div", { className: "planline " + kind });
-  d.append(icon(MARK[kind] ?? "dot", "ic"), el("span", { textContent: text }));
-  return d;
+/** The flow's view of somebody already hired. */
+function roleOf(s) {
+  return { handle: s.handle, name: s.name, dir: s.dir };
 }

package/templates/portal/js/views/todo.js

@@ -0,0 +1,62 @@
+/* The numbered step card shared by Getting started and the hiring flow on the Staff screen. */
+
+import { el } from "../dom.js";
+
+/**
+ * One numbered thing to do. Done ones fold to a single ticked line, and Change opens them again,
+ * so the list shows what is left without hiding what was done.
+ *
+ * `setLocked(reason)` greys a step that cannot start yet and says why in the pill; `null`
+ * unlocks it. A locked step shows no body, because a form you cannot use yet is a trap.
+ */
+export function todo(n, title, done) {
+  const card = el("section", { className: "todo" });
+  const num = el("span", { className: "todon" });
+  const pill = el("span", { className: "todopill" });
+  const change = el("button", { className: "ghbtn todochange", textContent: "Change" });
+  const head = el("div", { className: "todohead" }, [num, el("h3", { textContent: title }), pill, change]);
+  const hintEl = el("p", { className: "sub todohint" });
+  const body = el("div", { className: "todobody" });
+  card.append(head, hintEl, body);
+  let open = false;
+  let locked = null;
+  let isDone = done;
+  const paint = () => {
+    card.classList.toggle("done", isDone && !locked);
+    card.classList.toggle("locked", Boolean(locked));
+    num.textContent = isDone && !locked ? "✓" : String(n);
+    pill.textContent = locked ?? (isDone ? "Done" : "To do");
+    change.hidden = !isDone || Boolean(locked);
+    const shown = !locked && (!isDone || open);
+    body.hidden = !shown;
+    hintEl.hidden = !shown || !hintEl.textContent;
+  };
+  const setDone = (d) => {
+    isDone = Boolean(d);
+    paint();
+  };
+  change.onclick = () => {
+    open = !open;
+    change.textContent = open ? "Close" : "Change";
+    paint();
+  };
+  paint();
+  return {
+    card,
+    body,
+    setDone,
+    isDone: () => isDone,
+    setLocked: (reason) => {
+      locked = reason || null;
+      paint();
+    },
+    renumber: (m) => {
+      n = m;
+      paint();
+    },
+    hint: (text) => {
+      hintEl.textContent = text;
+      paint();
+    },
+  };
+}

package/templates/portal/js/yaml.js

@@ -0,0 +1,134 @@
+/* Colour for YAML.
+ *
+ * `org.yaml` and `staff.yaml` are the two files here a person actually reads closely, and they
+ * were served as one flat grey wall: the comments, the keys and the values all the same weight,
+ * so finding `mention_timeout_minutes` meant reading every line. Structure is the thing YAML has
+ * and prose does not, and showing it costs about eighty lines.
+ *
+ * Deliberately not a parser. It is a per-line tokeniser that knows comments, keys, quoted
+ * strings, numbers and the three keywords — enough to read by, and it cannot fail on a file it
+ * does not understand, because anything it does not recognise is left as plain text.
+ */
+
+import { el, esc } from "./dom.js";
+
+/** A `<pre>` holding the highlighted source. */
+export function yamlPre(text, className = "code yaml") {
+  const pre = el("pre", { className });
+  pre.innerHTML = yamlHTML(text);
+  return pre;
+}
+
+/** Escaped, highlighted HTML. Takes raw text: it does its own escaping. */
+export function yamlHTML(text) {
+  return String(text ?? "")
+    .split("\n")
+    .map(colourLine)
+    .join("\n");
+}
+
+/**
+ * The same, for text that is already HTML-escaped.
+ *
+ * The markdown renderer escapes a fenced block before it knows what language it is, and
+ * un-escaping four entities to escape them again is exact and cheaper than restructuring
+ * the renderer around one case.
+ */
+export function yamlHTMLFromEscaped(escaped) {
+  return yamlHTML(
+    String(escaped ?? "")
+      .replace(/&lt;/g, "<")
+      .replace(/&gt;/g, ">")
+      .replace(/&quot;/g, '"')
+      .replace(/&amp;/g, "&"),
+  );
+}
+
+const span = (cls, text) => '<span class="' + cls + '">' + esc(text) + "</span>";
+
+function colourLine(raw) {
+  const [code, comment] = splitComment(raw);
+  return (code ? colourCode(code) : "") + (comment ? span("yc", comment) : "");
+}
+
+/**
+ * Split a trailing comment off, without cutting a `#` that is inside a string.
+ *
+ * `marker: will   # the provenance tag` is a comment; `name: "a # b"` is not. YAML also only
+ * starts a comment at the beginning of a line or after whitespace, which is what keeps a
+ * `#hashtag` in a value intact.
+ */
+function splitComment(raw) {
+  let quote = null;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (quote) {
+      if (c === quote && raw[i - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      continue;
+    }
+    if (c === "#" && (i === 0 || /\s/.test(raw[i - 1]))) return [raw.slice(0, i), raw.slice(i)];
+  }
+  return [raw, ""];
+}
+
+const DOC = /^\s*(---|\.\.\.)\s*$/;
+/** Indent, then any run of list dashes: `  - - name: x` is two levels of list. */
+const LEAD = /^(\s*)((?:-\s+)*)/;
+/** A key is everything up to the first colon that is followed by a space or the end of line. */
+const KEY = /^([^\s"'#][^:]*?)(:)(\s|$)/;
+
+function colourCode(code) {
+  if (DOC.test(code)) return span("yp", code);
+
+  const lead = LEAD.exec(code);
+  const indent = lead[1];
+  const dashes = lead[2];
+  let rest = code.slice(indent.length + dashes.length);
+  let out = indent + (dashes ? span("yd", dashes) : "");
+
+  /* A line that opens a flow collection has no key of its own: `- { handle: cto }` is a list
+     item whose keys are all inside the braces, and taking "{ handle" for a key marked the
+     brace as part of the name. */
+  const key = /^[{[]/.test(rest) ? null : KEY.exec(rest);
+  if (key) {
+    out += span("yk", key[1]) + span("yp", key[2]) + key[3];
+    rest = rest.slice(key[1].length + 1 + key[3].length);
+  }
+  return out + colourValue(rest);
+}
+
+/* Strings, inline-map keys, the three keywords, numbers, and the punctuation that holds a flow
+   collection together. Ordered: a quoted string wins over everything inside it. */
+const TOKEN = new RegExp(
+  [
+    /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/, // 1 quoted string
+    /([A-Za-z_][\w.-]*)(\s*:)(?=\s|$)/, // 2,3 a key inside an inline map
+    /(\b(?:true|false|null|yes|no|on|off)\b|~)/, // 4 keywords
+    /(-?\d+(?:\.\d+)?\b)/, // 5 numbers
+    /([{}[\],])/, // 6 flow punctuation
+  ]
+    .map((r) => r.source)
+    .join("|"),
+  "g",
+);
+
+function colourValue(value) {
+  if (!value) return "";
+  let out = "";
+  let at = 0;
+  TOKEN.lastIndex = 0;
+  for (let m = TOKEN.exec(value); m; m = TOKEN.exec(value)) {
+    out += esc(value.slice(at, m.index));
+    if (m[1]) out += span("ys", m[1]);
+    else if (m[2]) out += span("yk", m[2]) + span("yp", m[3]);
+    else if (m[4]) out += span("yb", m[4]);
+    else if (m[5]) out += span("yn", m[5]);
+    else out += span("yp", m[6]);
+    at = m.index + m[0].length;
+  }
+  return out + esc(value.slice(at));
+}

package/templates/brain/.github/workflows/%%STAFF%%-pr-mention.yaml

@@ -1,50 +0,0 @@
-name: %%STAFF_UPPER%% on a product PR
-
-# Generated by roster. The body lives in %%OPS_REPO%%/.github/workflows/session.yaml.
-#
-# Amends an open PR on the product repo in response to a review comment, so the human can ask for
-# changes where they are already reading the diff instead of opening a ticket and cross-referencing.
-#
-# Not triggered directly. A forwarder in the PUBLIC product repo catches the mention and dispatches
-# here. The split exists because that repo is public: its Actions logs are world readable, so the
-# run that prints a charter and a chain of reasoning has to happen in a repo only we can see.
-#
-# NOTE: %%TOKENS%% are filled by `roster hire`. GitHub's own ${{ }} expressions are left alone.
-
-on:
-  repository_dispatch:
-    types: [pr-mention]
-
-  # Manual handle, for testing without leaving a comment on a public PR, and for re-running a
-  # request the dispatcher already consumed.
-  workflow_dispatch:
-    inputs:
-      pr:
-        description: "PR number on the product repo"
-        required: true
-      comment_id:
-        description: "id of the comment that triggered this"
-        required: true
-
-# Per PR. Several review comments in a row are the normal case; different PRs never contend.
-concurrency:
-  group: %%STAFF%%-pr-${{ github.event.inputs.pr || github.event.client_payload.pr }}
-  cancel-in-progress: false
-
-jobs:
-  amend:
-    uses: %%OPS_REPO%%/.github/workflows/session.yaml@main
-    with:
-      staff: %%STAFF%%
-      kind: pr-mention
-      ops_repo: %%OPS_REPO%%
-      model: %%MODEL%%
-      timeout_minutes: %%PR_MENTION_TIMEOUT%%
-      pr_number: ${{ github.event.inputs.pr || github.event.client_payload.pr }}
-      comment_id: ${{ github.event.inputs.comment_id || github.event.client_payload.comment_id }}
-    secrets:
-      APP_ID: ${{ secrets.%%SECRET_PREFIX%%_APP_ID }}
-      APP_PRIVATE_KEY: ${{ secrets.%%SECRET_PREFIX%%_APP_PRIVATE_KEY }}
-      PUBLIC_APP_ID: ${{ secrets.%%PUBLIC_SECRET_PREFIX%%_APP_ID }}
-      PUBLIC_APP_PRIVATE_KEY: ${{ secrets.%%PUBLIC_SECRET_PREFIX%%_APP_PRIVATE_KEY }}
-      AGENT_TOKEN: ${{ secrets.%%AGENT_SECRET%% }}