@edgehero/pi-dispatch-admin 0.1.1 → 0.1.3

package/README.md

@@ -2,36 +2,65 @@
   <img src="https://raw.githubusercontent.com/edgehero/pi-dispatch/main/docs/images/banner.png" alt="pi-dispatch — run the pi coding agent as a self-hosted service" width="880">
 </p>
 
-# @edgehero/pi-dispatch-admin
+# pi-dispatch — run the pi coding agent as a self-hosted service
 
-The **operator console** for [**pi-dispatch**](https://github.com/edgehero/pi-dispatch) — a
-[pi](https://github.com/earendil-works/pi) extension that adds a `/dispatch` command (a live TUI overlay +
-model-callable tools) for running the pi coding agent as a self-hosted service.
+**[pi](https://github.com/earendil-works/pi) is a superb coding agent — but it has no job queue, no spend limit, and, by its own README, no permission system.** pi-dispatch is the operational layer that adds exactly those, so you can run pi **unattended and safely**: on a cron schedule, on your repo's GitHub issues and PRs, or straight from the CLI — every job in an isolated container, with spend bounded *before* a single token is spent.
 
-> This is a **companion** to a running pi-dispatch deployment. It reads that deployment's Valkey queue and
-> run-history — install it in your own pi, alongside the pi-dispatch service. On its own it will show
-> "queue unreachable".
+> This npm package — **`@edgehero/pi-dispatch-admin`** — is the **operator console** (a pi extension). The queue, worker, container image, and GitHub receiver that make up the service live in the [main repo](https://github.com/edgehero/pi-dispatch); install this to **drive** a deployment, and get the whole thing there.
 
-## What it gives you
+## How it works
 
-- A `/dispatch` overlay: live queue state, day/week/month **spend meters** + a daily token counter, run
-  history with per-job token & cost, and a unified **triggers** pane (cron / label / comment / pull_request).
-- **Editable** triggers and **scheduled pause windows** ("quiet hours" per folder/repo), applied live.
-- **Confirm-gated** model tools so an agent can operate the deployment (change limits, manage triggers/pauses)
-  with **a human approving each change** — fail-closed when no operator is present.
-- The bundled `operate-pi-dispatch` **skill** documenting those human-in-the-loop gates.
+Every trigger produces the same job, through the same path — one queue, one container, one budget:
 
-## Install
+```
+   CLI  ·  cron  ·  GitHub issue / PR
+                │  enqueue
+                ▼
+        Valkey + BullMQ            durable queue — survives reboots, absorbs bursts
+                │
+                ▼
+     under the daily cap +         ── if not: refused here, before any spend
+       per-job turn budget?
+                │  yes
+                ▼
+        docker run --rm            one ephemeral container per job:
+   --cap-drop=ALL · non-root       --no-new-privileges · /job mounted read-only
+                │
+                ▼
+     pi + your .pi/skills          edits your code in place, opens a PR, comments back
+```
+
+- **The container is the boundary.** pi ships no permission system, so every job runs `--cap-drop=ALL`, non-root, ephemeral, with its instructions mounted read-only. That *is* the missing permission system — enforced by Docker, not hoped for.
+- **Spend is bounded before tokens.** A per-job turn budget plus daily / weekly / monthly caps, checked *before* a container starts. A runaway or a junk trigger costs you a refusal, not a surprise bill.
+- **Three triggers, one job.** A CLI command, a cron schedule, or a GitHub issue/PR — same queue, same box, same budget. Cron is the unattended one: recurring work on your own hardware, in an image you control.
+- **Your image, your tools.** Bake a project's toolchain into the Dockerfile; it ships **Playwright + Chromium**, so a flow can build a frontend, screenshot it, and iterate on the rendered result.
+
+## The console — `/dispatch`
+
+This extension puts a live TUI over the whole deployment in one command:
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/edgehero/pi-dispatch/main/docs/images/dispatch-dashboard.png" alt="The /dispatch panel: status, spend meters, triggers, runs, and settings" width="820">
+</p>
+
+- **Status & spend.** Queue and worker state, day/week/month **spend meters** + a daily token counter, and a run-history table with per-job token & cost.
+- **Triggers, editable live.** cron / label / comment / pull_request, with colored drill-ins showing *what fires* each one, *what it runs*, and its *trust model* — added, edited, and deleted without a restart.
+- **Quiet hours.** Scheduled pause windows per folder or repo: defer a scope's runs **between certain times** — recurring daily, weekday- and date-bounded, timezone-aware — and resume automatically. Deferred, never dropped, at zero budget cost.
+- **AI-operable, with a human gate.** Model-callable tools let an agent change limits and manage triggers and pause windows — but **every write pops an operator confirmation the model can't answer**, and is refused when no operator is present. The bundled `operate-pi-dispatch` **skill** teaches the agent to use those gates.
+- **Logs stay put.** Raw container output renders only in the overlay viewer, never into model context.
+
+## Install the console
 
 ```bash
 pi install npm:@edgehero/pi-dispatch-admin
 ```
 
-Then run pi and use `/dispatch`. Point it at your deployment with `VALKEY_URL` / `PI_LOGS_DIR` /
-`PI_SETTINGS_FILE` / `PI_TRIGGERS_FILE` / `PI_PAUSE_WINDOWS_FILE` (the same values your pi-dispatch worker uses).
+Then run pi and open `/dispatch`. Point it at your deployment with `VALKEY_URL` / `PI_LOGS_DIR` / `PI_SETTINGS_FILE` / `PI_TRIGGERS_FILE` / `PI_PAUSE_WINDOWS_FILE` — the same values your worker uses. It reads that deployment's queue and run history; on its own it will just say "queue unreachable."
+
+## Get the whole thing
+
+The queue, worker, container image, and GitHub webhook receiver — the actual service — are in the main repo. **Start there:**
 
-## The service
+### → **https://github.com/edgehero/pi-dispatch**
 
-The queue, worker, container image, and GitHub receiver live in the main repo:
-**https://github.com/edgehero/pi-dispatch** — start there. MIT. Read
-[`SECURITY.md`](https://github.com/edgehero/pi-dispatch/blob/main/SECURITY.md) before you rely on it.
+MIT, self-hosted. Read [`SECURITY.md`](https://github.com/edgehero/pi-dispatch/blob/main/SECURITY.md) before you rely on it — it states plainly what is and isn't defended (short version: the trust model is a GitHub Action's — whoever can merge to your default branch can instruct the agent).

package/dist/index.mjs

@@ -6591,6 +6591,51 @@ ${JSON.stringify(w)}` },
       return toolText(JSON.stringify(result));
     }
   });
+  pi.registerTool({
+    name: "dispatch_pause_edit",
+    label: "pi-dispatch edit pause window",
+    description: "Changes fields of an existing pause window (by array index from dispatch_pauses) and applies it live. Provide only the fields to change (scope/from/to/tz/days/dateFrom/dateTo); the rest keep their current value. The operator MUST approve a confirm dialog showing the before->after; refused with no interactive operator.",
+    executionMode: "sequential",
+    parameters: typebox_exports.Object({
+      index: typebox_exports.Integer({ minimum: 0 }),
+      scope: typebox_exports.Optional(typebox_exports.String()),
+      from: typebox_exports.Optional(typebox_exports.String()),
+      to: typebox_exports.Optional(typebox_exports.String()),
+      tz: typebox_exports.Optional(typebox_exports.String()),
+      days: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String())),
+      dateFrom: typebox_exports.Optional(typebox_exports.String()),
+      dateTo: typebox_exports.Optional(typebox_exports.String())
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const paths = resolvePaths(process.env);
+      const p = readPauseWindows({ pauseWindowsPath: paths.pauseWindowsPath });
+      const list = Array.isArray(p?.windows) ? p.windows : [];
+      const cur = list[params.index];
+      if (!cur) throw new Error(`no pause window at index ${params.index} (have ${list.length})`);
+      const before = buildPauseWindow(cur);
+      const merged = buildPauseWindow({
+        scope: params.scope ?? cur.scope,
+        from: params.from ?? cur.from,
+        to: params.to ?? cur.to,
+        tz: params.tz ?? cur.tz,
+        days: params.days ?? cur.days,
+        dateFrom: params.dateFrom ?? cur.dateFrom,
+        dateTo: params.dateTo ?? cur.dateTo
+      });
+      const result = await confirmedWrite(
+        ctx,
+        { title: `Edit pause window #${params.index + 1}`, message: `pause window #${params.index + 1}:
+${JSON.stringify(before)}
+\u2192 ${JSON.stringify(merged)}` },
+        () => {
+          const res = writePauseWindows({ pauseWindowsPath: paths.pauseWindowsPath, mutate: (l) => l.map((w, i) => i === params.index ? merged : w) });
+          if (res.invalid) throw new Error(`rejected: ${res.invalid}`);
+          return { applied: true, index: params.index, window: merged };
+        }
+      );
+      return toolText(JSON.stringify(result));
+    }
+  });
   pi.registerTool({
     name: "dispatch_trigger_delete",
     label: "pi-dispatch delete trigger",
@@ -6814,9 +6859,10 @@ async function handleDashboardAction(result, paths, ctx) {
   }
 }
 async function managePausesViaDialogs(paths, ui, notify) {
-  const action = await ui.select("Pause windows", ["Add a pause window", "Delete a pause window"]);
+  const action = await ui.select("Pause windows", ["Add a pause window", "Edit a pause window", "Delete a pause window"]);
   if (!action) return;
   if (action.startsWith("Add")) return addPauseWindowViaDialogs(paths, ui, notify);
+  if (action.startsWith("Edit")) return editPauseWindowViaDialogs(paths, ui, notify);
   return deletePauseWindowViaDialogs(paths, ui, notify);
 }
 async function addPauseWindowViaDialogs(paths, ui, notify) {
@@ -6838,6 +6884,47 @@ async function addPauseWindowViaDialogs(paths, ui, notify) {
   const res = writePauseWindows({ pauseWindowsPath: paths.pauseWindowsPath, mutate: (list) => [...list, w] });
   notify?.(res.ok ? `pause window added (live) \u2014 ${w.scope} ${w.from}-${w.to}` : `add rejected: ${res.invalid}`, res.ok ? "info" : "error");
 }
+async function editPauseWindowViaDialogs(paths, ui, notify) {
+  const p = readPauseWindows({ pauseWindowsPath: paths.pauseWindowsPath });
+  const list = Array.isArray(p?.windows) ? p.windows : [];
+  if (list.length === 0) {
+    notify?.("no pause windows to edit", "info");
+    return;
+  }
+  const labels = list.map((w, i) => `#${i + 1}  ${w.scope}  ${w.from}-${w.to} ${w.tz}${w.days ? ` [${w.days.join(",")}]` : ""}`);
+  const picked = await ui.select("Edit which pause window", labels);
+  if (!picked) return;
+  const index = labels.indexOf(picked);
+  if (index < 0) return;
+  const cur = list[index];
+  const ask = async (label, current) => ui.input(`${label} \u2014 blank keeps "${current}"`, current);
+  const keep = (v, current) => v === void 0 || v.trim() === "" ? current : v;
+  const scope = await ask("scope", cur.scope ?? "");
+  if (scope === void 0) return;
+  const from = await ask("from (HH:MM)", cur.from ?? "");
+  if (from === void 0) return;
+  const to = await ask("to (HH:MM)", cur.to ?? "");
+  if (to === void 0) return;
+  const tz = await ask("tz (IANA / UTC)", cur.tz ?? "UTC");
+  if (tz === void 0) return;
+  const days = await ask("days (space-separated)", (cur.days ?? []).join(" "));
+  if (days === void 0) return;
+  const dateFrom = await ask("dateFrom (YYYY-MM-DD)", cur.dateFrom ?? "");
+  if (dateFrom === void 0) return;
+  const dateTo = await ask("dateTo (YYYY-MM-DD)", cur.dateTo ?? "");
+  if (dateTo === void 0) return;
+  const merged = buildPauseWindow({
+    scope: keep(scope, cur.scope),
+    from: keep(from, cur.from),
+    to: keep(to, cur.to),
+    tz: keep(tz, cur.tz),
+    days: keep(days, cur.days),
+    dateFrom: keep(dateFrom, cur.dateFrom),
+    dateTo: keep(dateTo, cur.dateTo)
+  });
+  const res = writePauseWindows({ pauseWindowsPath: paths.pauseWindowsPath, mutate: (l) => l.map((w, i) => i === index ? merged : w) });
+  notify?.(res.ok ? `pause window #${index + 1} updated (live) \u2014 ${merged.scope} ${merged.from}-${merged.to}` : `edit rejected: ${res.invalid}`, res.ok ? "info" : "error");
+}
 async function deletePauseWindowViaDialogs(paths, ui, notify) {
   const p = readPauseWindows({ pauseWindowsPath: paths.pauseWindowsPath });
   const list = Array.isArray(p?.windows) ? p.windows : [];

package/package.json

@@ -1,13 +1,20 @@
 {
   "name": "@edgehero/pi-dispatch-admin",
-  "version": "0.1.1",
-  "description": "Operator console (a pi extension) + skill for the pi-dispatch self-hosted agent service: a /dispatch TUI for queue, spend, run history, triggers, and scheduled pause windows. Runs against a live pi-dispatch deployment.",
+  "version": "0.1.3",
+  "description": "Operator console (a pi extension) + skill for pi-dispatch: run the pi coding agent as a self-hosted service. A /dispatch TUI for the queue, spend caps, run history, editable triggers (cron/label/comment/PR), and scheduled pause windows — plus AI-operable, human-confirmed controls. Runs against a live pi-dispatch deployment.",
   "keywords": [
     "pi-package",
+    "pi-extension",
     "pi",
     "pi-coding-agent",
     "coding-agent",
-    "extension"
+    "ai-agent",
+    "autonomous-agents",
+    "self-hosted",
+    "job-queue",
+    "cron",
+    "tui",
+    "dashboard"
   ],
   "license": "MIT",
   "author": "Rob Boerman",

package/skills/operate-pi-dispatch/SKILL.md

@@ -30,9 +30,10 @@ dialog before it takes effect**:
 - `dispatch_set` — change a limit/setting (e.g. `dailyCap`, `weeklyCap`, `maxTurns`, `model`). Omit `value`
   to unset.
 - `dispatch_trigger_add` / `dispatch_trigger_edit` / `dispatch_trigger_delete` — manage triggers.
-- `dispatch_pause_add` / `dispatch_pause_delete` — manage scheduled pause windows (per folder/repo "quiet
-  hours": runs for a scope are deferred between certain times and auto-resume after; `dispatch_pauses` lists
-  them). Deferring never drops a job and costs no budget.
+- `dispatch_pause_add` / `dispatch_pause_edit` / `dispatch_pause_delete` — manage scheduled pause windows
+  (per folder/repo "quiet hours": runs for a scope are deferred between certain times and auto-resume after;
+  `dispatch_pauses` lists them with their index). `dispatch_pause_edit` is a partial change — pass the index
+  plus only the fields to alter. Deferring never drops a job and costs no budget.
 
 Use them like this: