@postact-js/cli 0.1.0

package/README.md

@@ -0,0 +1,20 @@
+# @postact-js/cli
+
+The [postact](https://postact.app) command line interface.
+
+```sh
+npm i -g @postact-js/cli
+postact login          # device-code login, opens the browser
+postact projects ls
+postact use acme       # pick a default project
+postact actions ls
+postact help
+```
+
+Flags: `-p/--project <slug>`, `--json`, `-d/--data <json|@file|->`, `--api <url>`, `--yes`.
+
+Config (session token + default project) lives in `%APPDATA%\postact\config.json` on Windows,
+`$XDG_CONFIG_HOME/postact/config.json` elsewhere, written `0600`. `POSTACT_API_URL` overrides the
+API base URL.
+
+Firing actions from application code? Use [`@postact-js/sdk`](https://www.npmjs.com/package/@postact-js/sdk).

package/dist/index.js

@@ -0,0 +1,932 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { parseArgs } from "node:util";
+
+// src/auth.ts
+import { spawn } from "node:child_process";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var dir = process.env.APPDATA ? join(process.env.APPDATA, "postact") : join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "postact");
+var file = join(dir, "config.json");
+function load() {
+  try {
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
+  } catch {
+    return {};
+  }
+}
+function save(c) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(file, `${JSON.stringify(c, null, 2)}
+`, { mode: 384 });
+}
+function apiUrl(override) {
+  return override || process.env.POSTACT_API_URL || load().apiUrl || "http://localhost:3001";
+}
+
+// src/auth.ts
+var CLIENT_ID = "postact-cli";
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function openBrowser(url) {
+  try {
+    if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+      spawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {}
+}
+async function post(base, path, body, token) {
+  const res = await fetch(`${base}${path}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...token ? { authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  return await res.json().catch(() => ({}));
+}
+async function getSession(base, token) {
+  const res = await fetch(`${base}/api/auth/get-session`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  return await res.json().catch(() => null);
+}
+async function login(apiOverride) {
+  const base = apiUrl(apiOverride);
+  const code = await post(base, "/api/auth/device/code", {
+    client_id: CLIENT_ID,
+    scope: ""
+  });
+  if (!code?.device_code)
+    throw new Error(code?.error_description || "could not start device login");
+  const url = code.verification_uri_complete ?? code.verification_uri ?? `${base}/device`;
+  console.log(`
+  Open:  ${url}`);
+  console.log(`  Code:  ${code.user_code}
+`);
+  openBrowser(url);
+  console.log("Waiting for approval…");
+  let interval = (code.interval ?? 5) * 1000;
+  for (;; ) {
+    await sleep(interval);
+    const tok = await post(base, "/api/auth/device/token", {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: code.device_code,
+      client_id: CLIENT_ID
+    });
+    if (tok?.access_token) {
+      save({ ...load(), apiUrl: base, token: tok.access_token });
+      const s = await getSession(base, tok.access_token);
+      console.log(`✓ Logged in as ${s?.user?.email ?? "?"}`);
+      return;
+    }
+    if (tok?.error === "authorization_pending")
+      continue;
+    if (tok?.error === "slow_down") {
+      interval += 5000;
+      continue;
+    }
+    throw new Error(tok?.error_description || tok?.error || "device authorization failed");
+  }
+}
+async function logout() {
+  const cfg = load();
+  if (cfg.token)
+    await post(apiUrl(), "/api/auth/sign-out", {}, cfg.token).catch(() => {});
+  save({ ...cfg, token: undefined, defaultProjectId: undefined });
+  console.log("Logged out.");
+}
+async function whoami() {
+  const cfg = load();
+  if (!cfg.token) {
+    console.log("Not logged in — run `postact login`.");
+    return;
+  }
+  const s = await getSession(apiUrl(), cfg.token);
+  if (!s?.user) {
+    console.log("Session expired — run `postact login`.");
+    return;
+  }
+  console.log(`${s.user.email}${s.user.name ? ` (${s.user.name})` : ""}`);
+}
+
+// src/commands.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// ../../node_modules/.bun/@elysiajs+eden@1.4.9+b64ed85232ac6ff0/node_modules/@elysiajs/eden/dist/chunk-I5KHAGLL.mjs
+var d = class extends Error {
+  constructor(e, s) {
+    super(s + "");
+    this.status = e;
+    this.value = s;
+  }
+};
+var i = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+var o = /(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{2}\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT(?:\+|-)\d{4}\s\([^)]+\)/;
+var u = /^(?:(?:(?:(?:0?[1-9]|[12][0-9]|3[01])[/\s-](?:0?[1-9]|1[0-2])[/\s-](?:19|20)\d{2})|(?:(?:19|20)\d{2}[/\s-](?:0?[1-9]|1[0-2])[/\s-](?:0?[1-9]|[12][0-9]|3[01]))))(?:\s(?:1[012]|0?[1-9]):[0-5][0-9](?::[0-5][0-9])?(?:\s[AP]M)?)?$/;
+var c = (t) => t.trim().length !== 0 && !Number.isNaN(Number(t));
+var a = (t, r) => {
+  if (typeof t != "string" || r?.parseDate === false)
+    return null;
+  let e = t.replace(/"/g, "");
+  if (i.test(e) || o.test(e) || u.test(e)) {
+    let s = new Date(e);
+    if (!Number.isNaN(s.getTime()))
+      return s;
+  }
+  return null;
+};
+var p = (t) => {
+  let r = t.charCodeAt(0), e = t.charCodeAt(t.length - 1);
+  return r === 123 && e === 125 || r === 91 && e === 93;
+};
+var f = (t, r) => JSON.parse(t, (e, s) => {
+  let n = a(s, r);
+  return n || s;
+});
+var g = (t, r) => {
+  if (!t)
+    return t;
+  if (c(t))
+    return +t;
+  if (t === "true")
+    return true;
+  if (t === "false")
+    return false;
+  if (r?.parseDate !== false) {
+    let e = a(t, r);
+    if (e)
+      return e;
+  }
+  if (p(t))
+    try {
+      return f(t, r);
+    } catch {}
+  return t;
+};
+var S = (t, r) => {
+  let e = t.data.toString();
+  return e === "null" ? null : g(e, r);
+};
+
+// ../../node_modules/.bun/@elysiajs+eden@1.4.9+b64ed85232ac6ff0/node_modules/@elysiajs/eden/dist/chunk-TTKI5TQ7.mjs
+var C = class {
+  constructor(t) {
+    this.url = t;
+    this.ws = new WebSocket(t);
+  }
+  ws;
+  send(t) {
+    return Array.isArray(t) ? (t.forEach((n) => this.send(n)), this) : (this.ws.send(typeof t == "object" ? JSON.stringify(t) : t.toString()), this);
+  }
+  on(t, n, r) {
+    return this.addEventListener(t, n, r);
+  }
+  off(t, n, r) {
+    return this.ws.removeEventListener(t, n, r), this;
+  }
+  subscribe(t, n) {
+    return this.addEventListener("message", t, n);
+  }
+  addEventListener(t, n, r) {
+    return this.ws.addEventListener(t, (o2) => {
+      if (t === "message") {
+        let i2 = S(o2);
+        n({ ...o2, data: i2 });
+      } else
+        n(o2);
+    }, r), this;
+  }
+  removeEventListener(t, n, r) {
+    return this.off(t, n, r), this;
+  }
+  close() {
+    return this.ws.close(), this;
+  }
+};
+var X = ["get", "post", "put", "delete", "patch", "options", "head", "connect", "subscribe"];
+var P = (e, t) => typeof t == "function" ? t(e) : t === true;
+var _ = ["localhost", "127.0.0.1", "0.0.0.0"];
+var q = typeof FileList > "u";
+var H = (e) => q ? e instanceof Blob : e instanceof FileList || e instanceof File;
+var Y = (e) => {
+  if (!e)
+    return false;
+  for (let t in e)
+    if (H(e[t]) || Array.isArray(e[t]) && e[t].find(H))
+      return true;
+  return false;
+};
+var K = (e) => q ? e : new Promise((t) => {
+  let n = new FileReader;
+  n.onload = () => {
+    let r = new File([n.result], e.name, { lastModified: e.lastModified, type: e.type });
+    t(r);
+  }, n.readAsArrayBuffer(e);
+});
+var A = async (e, t, n = {}, r = {}) => {
+  if (Array.isArray(e)) {
+    for (let o2 of e)
+      if (!Array.isArray(o2))
+        r = await A(o2, t, n, r);
+      else {
+        let i2 = o2[0];
+        if (typeof i2 == "string")
+          r[i2.toLowerCase()] = o2[1];
+        else
+          for (let [s, u2] of i2)
+            r[s.toLowerCase()] = u2;
+      }
+    return r;
+  }
+  if (!e)
+    return r;
+  switch (typeof e) {
+    case "function":
+      if (e instanceof Headers)
+        return A(e, t, n, r);
+      let o2 = await e(t, n);
+      return o2 ? A(o2, t, n, r) : r;
+    case "object":
+      if (e instanceof Headers)
+        return e.forEach((i2, s) => {
+          r[s.toLowerCase()] = i2;
+        }), r;
+      for (let [i2, s] of Object.entries(e))
+        r[i2.toLowerCase()] = s;
+      return r;
+    default:
+      return r;
+  }
+};
+function V(e, t) {
+  let n = e.split(`
+`), r = {};
+  for (let o2 of n) {
+    if (!o2 || o2.startsWith(":"))
+      continue;
+    let i2 = o2.indexOf(":");
+    if (i2 > 0) {
+      let s = o2.slice(0, i2).trim(), u2 = o2.slice(i2 + 1).replace(/^ /, "");
+      r[s] = u2 && g(u2, t);
+    }
+  }
+  return Object.keys(r).length > 0 ? r : null;
+}
+function* B(e, t) {
+  let n;
+  for (;(n = e.value.indexOf(`
+
+`)) !== -1; ) {
+    let r = e.value.slice(0, n);
+    if (e.value = e.value.slice(n + 2), r.trim()) {
+      let o2 = V(r, t);
+      o2 && (yield o2);
+    }
+  }
+}
+async function* U(e, t) {
+  let n = e.body;
+  if (!n)
+    return;
+  let r = n.getReader(), o2 = new TextDecoder("utf-8");
+  if (e.headers.get("Content-Type")?.startsWith("text/event-stream")) {
+    let i2 = { value: "" };
+    try {
+      for (;; ) {
+        let { done: u2, value: x } = await r.read();
+        if (u2)
+          break;
+        let m = typeof x == "string" ? x : o2.decode(x, { stream: true });
+        i2.value += m, yield* B(i2, t);
+      }
+      let s = o2.decode();
+      if (s && (i2.value += s), yield* B(i2, t), i2.value.trim()) {
+        let u2 = V(i2.value, t);
+        u2 && (yield u2);
+      }
+    } finally {
+      r.releaseLock();
+    }
+  } else
+    try {
+      for (;; ) {
+        let { done: i2, value: s } = await r.read();
+        if (i2)
+          break;
+        yield g(typeof s == "string" ? s : o2.decode(s, { stream: true }), { parseDate: t?.parseDate });
+      }
+    } finally {
+      r.releaseLock();
+    }
+}
+var L = (e, t, n = [], r) => new Proxy(() => {}, { get(o2, i2) {
+  if (i2 === "~path")
+    return "/" + n.join("/");
+  if (!(n.length === 0 && (i2 === "then" || i2 === "catch" || i2 === "finally")))
+    return L(e, t, [...n, i2], r);
+}, apply(o2, i2, [s, u2]) {
+  if (!s || u2 || typeof s == "object" && Object.keys(s).length !== 1 || X.includes(n.at(-1))) {
+    let x = [...n], m = x.pop(), b = "/" + x.join("/"), { fetcher: G = fetch, headers: R, onRequest: g2, onResponse: D, fetch: $ } = t, E = m === "get" || m === "head" || m === "subscribe", M = E ? s?.query : u2?.query, F = "";
+    if (M) {
+      let a2 = (k, d2) => {
+        d2 != null && (d2 instanceof Date && (d2 = d2.toISOString()), F += (F ? "&" : "?") + `${encodeURIComponent(k)}=${encodeURIComponent(typeof d2 == "object" ? JSON.stringify(d2) : d2 + "")}`);
+      };
+      for (let [k, d2] of Object.entries(M)) {
+        if (Array.isArray(d2)) {
+          for (let T of d2)
+            a2(k, T);
+          continue;
+        }
+        a2(k, d2);
+      }
+    }
+    if (m === "subscribe") {
+      let a2 = e.replace(/^([^]+):\/\//, e.startsWith("https://") ? "wss://" : e.startsWith("http://") || _.find((k) => e.includes(k)) ? "ws://" : "wss://") + b + F;
+      return new C(a2);
+    }
+    return (async () => {
+      R = await A(R, b, u2);
+      let a2 = { method: m?.toUpperCase(), body: s, ...$, headers: R };
+      a2.headers = { ...R, ...await A(E ? s?.headers : u2?.headers, b, a2) };
+      let k = E && typeof s == "object" ? s.fetch : u2?.fetch, T = (E && typeof s == "object" ? s.throwHttpError : u2?.throwHttpError) ?? t.throwHttpError;
+      if (a2 = { ...a2, ...k }, E && delete a2.body, g2) {
+        Array.isArray(g2) || (g2 = [g2]);
+        for (let y of g2) {
+          let c2 = await y(b, a2);
+          typeof c2 == "object" && (a2 = { ...a2, ...c2, headers: { ...a2.headers, ...await A(c2.headers, b, a2) } });
+        }
+      }
+      if (E && delete a2.body, Y(s)) {
+        let y = new FormData, c2 = (f2) => {
+          if (typeof f2 == "string" || H(f2))
+            return false;
+          if (typeof f2 == "object") {
+            if (f2 !== null)
+              return true;
+            if (f2 instanceof Date)
+              return false;
+          }
+          return false;
+        }, w = async (f2) => f2 instanceof File ? await K(f2) : c2(f2) ? JSON.stringify(f2) : f2;
+        for (let [f2, p2] of Object.entries(a2.body)) {
+          if (Array.isArray(p2)) {
+            if (p2.some((S2) => typeof S2 == "object" && S2 !== null && !H(S2)))
+              y.append(f2, JSON.stringify(p2));
+            else
+              for (let S2 = 0;S2 < p2.length; S2++) {
+                let z = p2[S2], Q = await w(z);
+                y.append(f2, Q);
+              }
+            continue;
+          }
+          if (q) {
+            if (Array.isArray(p2))
+              for (let O of p2)
+                y.append(f2, await w(O));
+            else
+              y.append(f2, await w(p2));
+            continue;
+          }
+          if (p2 instanceof File) {
+            y.append(f2, await K(p2));
+            continue;
+          }
+          if (p2 instanceof FileList) {
+            for (let O = 0;O < p2.length; O++)
+              y.append(f2, await K(p2[O]));
+            continue;
+          }
+          y.append(f2, await w(p2));
+        }
+        a2.body = y;
+      } else
+        typeof s == "object" ? (a2.headers["content-type"] = "application/json", a2.body = JSON.stringify(s)) : s != null && (a2.headers["content-type"] = "text/plain");
+      if (E && delete a2.body, g2) {
+        Array.isArray(g2) || (g2 = [g2]);
+        for (let y of g2) {
+          let c2 = await y(b, a2);
+          typeof c2 == "object" && (a2 = { ...a2, ...c2, headers: { ...a2.headers, ...await A(c2.headers, b, a2) } });
+        }
+      }
+      u2?.headers?.["content-type"] && (a2.headers["content-type"] = u2?.headers["content-type"]);
+      let I = e + b + F, l;
+      try {
+        l = await (r?.handle(new Request(I, a2)) ?? G(I, a2));
+      } catch (y) {
+        let c2 = new d(503, y);
+        if (P(c2, T))
+          throw c2;
+        return { data: null, error: c2, response: undefined, status: 503, headers: undefined };
+      }
+      let h = null, v = null;
+      if (D) {
+        Array.isArray(D) || (D = [D]);
+        for (let y of D)
+          try {
+            let c2 = await y(l.clone());
+            if (c2 != null) {
+              h = c2;
+              break;
+            }
+          } catch (c2) {
+            c2 instanceof d ? v = c2 : v = new d(422, c2);
+            break;
+          }
+      }
+      if (h !== null)
+        return { data: h, error: v, response: l, status: l.status, headers: l.headers };
+      switch (l.headers.get("Content-Type")?.split(";")[0]) {
+        case "text/event-stream":
+          h = U(l, { parseDate: t.parseDate });
+          break;
+        case "application/json":
+          h = JSON.parse(await l.text(), (c2, w) => {
+            if (typeof w != "string")
+              return w;
+            let f2 = a(w, { parseDate: t.parseDate });
+            return f2 || w;
+          });
+          break;
+        case "application/octet-stream":
+          h = await l.arrayBuffer();
+          break;
+        case "multipart/form-data":
+          let y = await l.formData();
+          h = {}, y.forEach((c2, w) => {
+            h[w] = c2;
+          });
+          break;
+        default:
+          l.headers.get("content-type")?.startsWith("text/") && l.headers.get("transfer-encoding") === "chunked" && !l.headers.has("content-length") ? h = U(l, { parseDate: t.parseDate }) : h = await l.text().then((c2) => g(c2, { parseDate: t.parseDate }));
+      }
+      if (l.status >= 300 || l.status < 200) {
+        if (v = new d(l.status, h), P(v, T))
+          throw v;
+        h = null;
+      }
+      return { data: h, error: v, response: l, status: l.status, headers: l.headers };
+    })();
+  }
+  return typeof s == "object" ? L(e, t, [...n, Object.values(s)[0]], r) : L(e, t, n);
+} });
+var se = (e, t = {}) => typeof e == "string" ? (t.keepDomain || (e.includes("://") || (e = (_.find((n) => e.includes(n)) ? "http://" : "https://") + e), e.endsWith("/") && (e = e.slice(0, -1))), L(e, t)) : (typeof window < "u" && console.warn("Elysia instance server found on client side, this is not recommended for security reason. Use generic type instead."), L("http://e.ly", t, [], e));
+
+// src/client.ts
+function client(apiOverride) {
+  const cfg = load();
+  if (!cfg.token)
+    throw new Error("Not logged in — run `postact login`.");
+  return se(apiUrl(apiOverride), {
+    headers: { authorization: `Bearer ${cfg.token}` }
+  });
+}
+function unwrap(res) {
+  if (res.error) {
+    const value = res.error.value;
+    const body = typeof value === "object" && value !== null ? value : {};
+    const msg = typeof body.error === "string" ? body.error : typeof body.message === "string" ? body.message : `request failed (${res.status})`;
+    throw Object.assign(new Error(msg), { status: res.status });
+  }
+  return res.data;
+}
+var UUID = /^[0-9a-f-]{36}$/i;
+async function resolveProjectId(api, want) {
+  const target = want || load().defaultProjectId;
+  if (!target)
+    throw new Error("No project selected — run `postact use <slug>` or pass --project <slug>.");
+  if (UUID.test(target))
+    return target;
+  const { projects } = unwrap(await api.app.projects.get());
+  const p2 = projects.find((x) => x.slug === target || x.id === target);
+  if (!p2)
+    throw new Error(`No project matching "${target}".`);
+  return p2.id;
+}
+function setDefaultProject(id) {
+  save({ ...load(), defaultProjectId: id });
+}
+var cell = (v) => v == null ? "" : typeof v === "object" ? JSON.stringify(v) : String(v);
+function output(data, json) {
+  if (json || !Array.isArray(data)) {
+    console.log(JSON.stringify(data ?? null, null, 2));
+    return;
+  }
+  const rows = data;
+  if (rows.length === 0) {
+    console.log("(none)");
+    return;
+  }
+  const cols = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+  const widths = cols.map((c2) => Math.max(c2.length, ...rows.map((r) => cell(r[c2]).length)));
+  const line = (cells) => cells.map((c2, i2) => cell(c2).padEnd(widths[i2])).join("  ");
+  console.log(line(cols));
+  for (const r of rows)
+    console.log(line(cols.map((c2) => r[c2])));
+}
+
+// src/commands.ts
+var str = (v) => typeof v === "string" ? v : undefined;
+var json = (ctx) => ctx.flags.json === true;
+async function data(ctx) {
+  const d2 = str(ctx.flags.data);
+  if (!d2)
+    return {};
+  const raw = d2 === "-" ? await Bun.stdin.text() : d2.startsWith("@") ? readFileSync2(d2.slice(1), "utf8") : d2;
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null)
+    throw new Error("--data must be a JSON object");
+  return parsed;
+}
+async function body(ctx, extra) {
+  const base = await data(ctx);
+  for (const [k, v] of Object.entries(extra))
+    if (v !== undefined)
+      base[k] = v;
+  return base;
+}
+async function withProject(ctx) {
+  const api = client(str(ctx.flags.api));
+  const pid = await resolveProjectId(api, str(ctx.flags.project));
+  return { api, pid };
+}
+var need = (ctx, i2, name) => {
+  const v = ctx.args[i2];
+  if (!v)
+    throw new Error(`missing <${name}>`);
+  return v;
+};
+var commands = {
+  projects: {
+    async ls(ctx) {
+      const api = client(str(ctx.flags.api));
+      output(unwrap(await api.app.projects.get()).projects, json(ctx));
+    },
+    async get(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).get()), json(ctx));
+    },
+    async create(ctx) {
+      const api = client(str(ctx.flags.api));
+      const name = str(ctx.flags.name) ?? need(ctx, 0, "name");
+      const res = unwrap(await api.app.projects.post({ name }));
+      console.log(`Created project ${res.projectId}`);
+      console.log(`Secret key (shown once): ${res.sk}`);
+    },
+    async use(ctx) {
+      const api = client(str(ctx.flags.api));
+      const pid = await resolveProjectId(api, need(ctx, 0, "slug|id"));
+      setDefaultProject(pid);
+      console.log(`Default project set to ${pid}`);
+    }
+  },
+  actions: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const { actions } = unwrap(await api.app.p({ projectId: pid }).actions.get());
+      output(actions.map((a2) => ({
+        id: a2.id,
+        name: a2.name,
+        slug: a2.slug,
+        trigger: a2.trigger,
+        events: a2.eventCount
+      })), json(ctx));
+    },
+    async get(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "actionId");
+      output(unwrap(await api.app.p({ projectId: pid }).actions({ actionId: id }).get()).action, json(ctx));
+    },
+    async create(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const b = await body(ctx, {
+        name: str(ctx.flags.name),
+        slug: str(ctx.flags.slug),
+        trigger: str(ctx.flags.trigger)
+      });
+      output(unwrap(await api.app.p({ projectId: pid }).actions.post(b)).action, json(ctx));
+    },
+    async update(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "actionId");
+      const b = await body(ctx, {
+        name: str(ctx.flags.name),
+        slug: str(ctx.flags.slug),
+        trigger: str(ctx.flags.trigger)
+      });
+      output(unwrap(await api.app.p({ projectId: pid }).actions({ actionId: id }).patch(b)).action, json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "actionId");
+      output(unwrap(await api.app.p({ projectId: pid }).actions({ actionId: id }).delete()), json(ctx));
+    },
+    async run(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "actionId");
+      output(unwrap(await api.app.p({ projectId: pid }).actions({ actionId: id }).run.post({})), json(ctx));
+    }
+  },
+  people: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const { people } = unwrap(await api.app.p({ projectId: pid }).filters({ filterId: "people" }).get());
+      output(people, json(ctx));
+    },
+    async get(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "personId");
+      output(unwrap(await api.app.p({ projectId: pid }).people({ personId: id }).get()), json(ctx));
+    },
+    async create(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const email = str(ctx.flags.email) ?? need(ctx, 0, "email");
+      const fields = await data(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).people.post({ email, fields })).person, json(ctx));
+    },
+    async update(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "personId");
+      const fields = await data(ctx);
+      const b = { email: str(ctx.flags.email) ?? "", fields, originalKeys: Object.keys(fields) };
+      output(unwrap(await api.app.p({ projectId: pid }).people({ personId: id }).patch(b)).person, json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "personId");
+      output(unwrap(await api.app.p({ projectId: pid }).people({ personId: id }).delete()).person, json(ctx));
+    }
+  },
+  events: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const filterId = str(ctx.flags.filter) ?? ctx.args[0] ?? "queue";
+      const res = unwrap(await api.app.p({ projectId: pid }).filters({ filterId }).get());
+      output("events" in res ? res.events : res, json(ctx));
+    },
+    async reply(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "eventId");
+      const b = {
+        templateId: str(ctx.flags.template) ?? null,
+        body: str(ctx.flags.body) ?? "",
+        close: ctx.flags.close === true
+      };
+      output(unwrap(await api.app.p({ projectId: pid }).events({ eventId: id }).reply.post(b)), json(ctx));
+    },
+    async status(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "eventId");
+      const status = str(ctx.flags.status) ?? need(ctx, 1, "open|closed");
+      output(unwrap(await api.app.p({ projectId: pid }).events({ eventId: id }).status.post({ status })), json(ctx));
+    }
+  },
+  filters: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).get()).nav.savedFilters, json(ctx));
+    },
+    async view(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "filterId");
+      output(unwrap(await api.app.p({ projectId: pid }).filters({ filterId: id }).get()), json(ctx));
+    },
+    async create(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const b = await body(ctx, { name: str(ctx.flags.name), scope: str(ctx.flags.scope) });
+      output(unwrap(await api.app.p({ projectId: pid }).filters.post(b)).filter, json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "filterId");
+      output(unwrap(await api.app.p({ projectId: pid }).filters({ filterId: id }).delete()), json(ctx));
+    }
+  },
+  templates: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).emails.templates.get()).templates, json(ctx));
+    },
+    async get(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "templateId");
+      output(unwrap(await api.app.p({ projectId: pid }).emails.templates({ id }).get()).template, json(ctx));
+    },
+    async create(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const b = await body(ctx, {
+        name: str(ctx.flags.name),
+        subject: str(ctx.flags.subject),
+        bodyHtml: str(ctx.flags.body)
+      });
+      output(unwrap(await api.app.p({ projectId: pid }).emails.templates.post(b)).template, json(ctx));
+    },
+    async update(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "templateId");
+      const b = await body(ctx, {
+        name: str(ctx.flags.name),
+        subject: str(ctx.flags.subject),
+        bodyHtml: str(ctx.flags.body)
+      });
+      output(unwrap(await api.app.p({ projectId: pid }).emails.templates({ id }).patch(b)), json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "templateId");
+      output(unwrap(await api.app.p({ projectId: pid }).emails.templates({ id }).delete()), json(ctx));
+    }
+  },
+  emails: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).emails.get()).emails, json(ctx));
+    }
+  },
+  keys: {
+    async show(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).settings.keys.get()), json(ctx));
+    },
+    async rotate(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const res = unwrap(await api.app.p({ projectId: pid }).settings.keys.rotate.post({}));
+      console.log(`New secret key (shown once): ${res.sk}`);
+    }
+  },
+  vault: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).settings.vault.get()).secrets, json(ctx));
+    },
+    async set(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const name = str(ctx.flags.name) ?? need(ctx, 0, "NAME");
+      const value = str(ctx.flags.value) ?? need(ctx, 1, "value");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.vault.post({ name, value })), json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "secretId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.vault({ secretId: id }).delete()), json(ctx));
+    }
+  },
+  domains: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).settings.domains.get()).domains, json(ctx));
+    },
+    async records(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "domainId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.domains({ id }).records.get()).records, json(ctx));
+    },
+    async add(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const domain = str(ctx.flags.domain) ?? need(ctx, 0, "domain");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.domains.post({ domain })), json(ctx));
+    },
+    async verify(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "domainId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.domains({ id }).verify.post({})), json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const id = need(ctx, 0, "domainId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.domains({ id }).delete()), json(ctx));
+    }
+  },
+  collaborators: {
+    async ls(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).settings.collaborators.get()), json(ctx));
+    },
+    async invite(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const email = str(ctx.flags.email) ?? need(ctx, 0, "email");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.collaborators.post({ email })), json(ctx));
+    },
+    async resend(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const inviteId = need(ctx, 0, "inviteId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.collaborators.invites({ inviteId }).resend.post({})), json(ctx));
+    },
+    async "rm-invite"(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const inviteId = need(ctx, 0, "inviteId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.collaborators.invites({ inviteId }).delete()), json(ctx));
+    },
+    async "rm-member"(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const memberId = need(ctx, 0, "memberId");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.collaborators.members({ memberId }).delete()), json(ctx));
+    }
+  },
+  branding: {
+    async show(ctx) {
+      const { api, pid } = await withProject(ctx);
+      output(unwrap(await api.app.p({ projectId: pid }).settings.branding.get()), json(ctx));
+    },
+    async set(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const b = await body(ctx, {});
+      output(unwrap(await api.app.p({ projectId: pid }).settings.branding.patch(b)), json(ctx));
+    }
+  },
+  project: {
+    async rename(ctx) {
+      const { api, pid } = await withProject(ctx);
+      const b = await body(ctx, { name: str(ctx.flags.name), slug: str(ctx.flags.slug) });
+      output(unwrap(await api.app.p({ projectId: pid }).settings.project.patch(b)), json(ctx));
+    },
+    async rm(ctx) {
+      const { api, pid } = await withProject(ctx);
+      if (ctx.flags.yes !== true)
+        throw new Error("Refusing to delete a project without --yes");
+      output(unwrap(await api.app.p({ projectId: pid }).settings.project.delete()), json(ctx));
+    }
+  }
+};
+
+// src/index.ts
+var options = {
+  help: { type: "boolean", short: "h" },
+  json: { type: "boolean" },
+  yes: { type: "boolean" },
+  close: { type: "boolean" },
+  project: { type: "string", short: "p" },
+  api: { type: "string" },
+  data: { type: "string", short: "d" },
+  name: { type: "string" },
+  slug: { type: "string" },
+  email: { type: "string" },
+  trigger: { type: "string" },
+  status: { type: "string" },
+  template: { type: "string" },
+  body: { type: "string" },
+  subject: { type: "string" },
+  scope: { type: "string" },
+  value: { type: "string" },
+  domain: { type: "string" },
+  filter: { type: "string" }
+};
+function parseArgv(args) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options });
+  const [group, verb, ...rest] = positionals;
+  return { group, verb, rest, flags: values };
+}
+function help() {
+  console.log(`postact — CLI for the postact dashboard API
+
+Usage: postact <command> [verb] [args] [--flags]
+
+Auth:
+  login              device-code login (opens the browser)
+  logout             revoke + clear the local token
+  whoami             show the signed-in user
+
+Commands:`);
+  for (const [g2, verbs] of Object.entries(commands))
+    console.log(`  ${g2.padEnd(14)} ${Object.keys(verbs).join(", ")}`);
+  console.log(`
+Flags: -p/--project <slug|id>, --json, -d/--data <json|@file|->, --api <url>, --yes,
+       plus field shortcuts (--name, --email, --slug, --trigger, --status, --body, …)`);
+}
+async function main() {
+  const { group, verb, rest, flags } = parseArgv(process.argv.slice(2));
+  if (!group || group === "help" || flags.help === true)
+    return help();
+  if (group === "login")
+    return login(typeof flags.api === "string" ? flags.api : undefined);
+  if (group === "logout")
+    return logout();
+  if (group === "whoami")
+    return whoami();
+  const grp = commands[group];
+  if (!grp)
+    throw new Error(`unknown command "${group}" — run \`postact help\``);
+  const handler = verb ? grp[verb] : undefined;
+  if (!handler)
+    throw new Error(`unknown verb "${verb ?? ""}" for ${group}
+verbs: ${Object.keys(grp).join(", ")}`);
+  await handler({ args: rest, flags });
+}
+if (__require.main == __require.module) {
+  main().catch((e) => {
+    console.error(`Error: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  });
+}
+export {
+  parseArgv
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@postact-js/cli",
+  "version": "0.1.0",
+  "description": "Command line interface for postact.",
+  "type": "module",
+  "bin": {
+    "postact": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://postact.app",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "build": "bun build src/index.ts --target=node --outdir dist --banner \"#!/usr/bin/env node\"",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@elysiajs/eden": "^1.4.9",
+    "@types/bun": "^1.3.14",
+    "@userdeck/backend": "workspace:*",
+    "typescript": "^5"
+  }
+}