@acsetra/runner 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# @acsetra/runner
+
+The Runner CLI for Node — author and run **hosted Runner apps** from your
+terminal. A thin, dependency-free client (Node 18+, uses global `fetch`) that
+mirrors the Python `acsetra` package: every authoring command serializes to
+`{op, args}` and is POSTed to the hosted API, where all validation runs
+server-side. Same grammar, same token, interchangeable with the Python CLI.
+
+## Use
+
+```bash
+npx -y @acsetra/runner signin
+npx -y @acsetra/runner whoami
+# or install globally:
+npm install -g @acsetra/runner
+runner app create crm --label "CRM"
+runner set put crm contacts ada --json '{"role":"eng"}'
+runner doctor <workspace>.crm && runner compile <workspace>.crm
+runner dev <workspace>.crm
+```
+
+Exposes `runner` and `acsetra` binaries. The token is cached at
+`~/.config/acsetra/credentials` (0600) — shared with the Python client, so you
+can use either interchangeably.
+
+## Environment overrides
+
+`ACSETRA_API_BASE`, `ACSETRA_TOKEN`, `ACSETRA_WORKSPACE`, `ACSETRA_SCOPE`.
+
+Run `runner help` for the full verb list.

package/bin/runner.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+// runner — the Node CLI entry. Mirrors acsetra_cli/__main__.py: a few client
+// commands (signin, whoami, docs, dev), everything else serialized to /api/v1/op.
+import fs from "node:fs";
+import path from "node:path";
+import http from "node:http";
+import https from "node:https";
+import { setTimeout as sleep } from "node:timers/promises";
+import * as config from "../lib/config.js";
+import * as api from "../lib/api.js";
+import { toOp, VerbError } from "../lib/verbs.js";
+
+const HELP = `runner — author and run hosted Runner apps.
+
+Session
+  runner signin [--api URL]      sign in (device flow); caches a token
+  runner whoami                  show the signed-in user + workspace
+  runner workspaces [--use SLUG] list workspaces; --use switches the active one
+  runner use <slug>              set the active workspace for this project
+  runner logout                  forget the cached token
+  runner usage [--days N]        metered usage vs your plan caps
+  runner tokens [new|list|revoke <id>]
+
+Context + dev
+  runner docs pull [-S scope]    refresh CLAUDE.md + .runner/docs/*
+  runner dev <app> [--hosted]    localhost surface proxied to hosted Runner
+
+Authoring (serialized to /api/v1/op)
+  runner app create <name>; runner apps
+  runner ls | inspect <set>      (-S scope)
+  runner set put <set> <row> --json '{…}'
+  runner pipe <code> -S <scope> --writes c:l ; runner w <code> snippet -b -
+  runner css|component|asset|behavior|head <sub> …
+  runner read <code> ; runner run <pipeline> -i '{…}' ; runner runs <id>
+  runner doctor <app> ; runner compile <app> ; runner op <name> --json '{…}'
+
+Env: ACSETRA_API_BASE, ACSETRA_TOKEN, ACSETRA_WORKSPACE, ACSETRA_SCOPE`;
+
+function emit(result) {
+  if (result && typeof result === "object" && "result" in result &&
+      Object.keys(result).every(k => ["ok", "result"].includes(k))) result = result.result;
+  if (result && typeof result === "object" && "result" in result &&
+      Object.keys(result).every(k => ["ok", "op", "scope", "result"].includes(k))) result = result.result;
+  console.log(JSON.stringify(result, null, 2));
+}
+function fail(msg, code = 1) { console.error("REJECTED: " + msg); process.exit(code); }
+function opt(rest, flag) { const i = rest.indexOf(flag); return i >= 0 && i + 1 < rest.length ? rest[i + 1] : null; }
+
+async function signin(rest) {
+  const apiArg = opt(rest, "--api");
+  if (apiArg) config.setProject({ api_base: apiArg.replace(/\/$/, "") });
+  const base = config.apiBase();
+  console.error(`Signing in to ${base}`);
+  let start;
+  try { start = await api.deviceStart("cli"); }
+  catch (e) { console.error("could not start sign-in: " + e.message); return 1; }
+  const verify = start.verification_uri_complete || start.verification_uri;
+  console.log(`\n  To sign in, visit:\n\n    ${verify}\n`);
+  console.error(`  and confirm the code:  ${start.user_code}\n`);
+  if (!rest.includes("--no-browser")) openUrl(verify);
+  const interval = Math.max(1, start.interval || 5);
+  const deadline = Date.now() + (start.expires_in || 900) * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000);
+    const { status, body } = await api.deviceToken(start.device_code);
+    if (status === 200 && body.token) {
+      const cred = config.loadUser();
+      Object.assign(cred, { api_base: base, token: body.token, workspace: body.workspace, scope_root: body.scope_root });
+      config.saveUser(cred);
+      config.setProject({ api_base: base, workspace: body.workspace, default_scope: body.scope_root });
+      console.error(`\n✓ Signed in. Workspace: ${body.workspace}`);
+      return 0;
+    }
+    if (body.status === "denied") { console.error("\n✗ Sign-in denied."); return 1; }
+    if (body.status === "expired" || status === 410) { console.error("\n✗ Code expired. Run `runner signin` again."); return 1; }
+  }
+  console.error("\n✗ Timed out waiting for approval.");
+  return 1;
+}
+
+async function docsPull(rest) {
+  const scope = opt(rest, "-S") || opt(rest, "--scope") || config.defaultScope();
+  let pack;
+  try { pack = await api.get("/api/v1/context-pack", scope ? { scope } : {}); }
+  catch (e) { console.error("docs pull failed: " + e.message); return 1; }
+  let n = 0;
+  for (const [rel, content] of Object.entries(pack.files)) {
+    if (path.basename(rel).endsWith(".local.md")) continue;
+    fs.mkdirSync(path.dirname(rel), { recursive: true });
+    fs.writeFileSync(rel, content); n++;
+    console.error("  " + rel);
+  }
+  config.setProject({ context_version: pack.version, workspace: pack.workspace });
+  console.error(`docs: wrote ${n} files (version ${pack.version})`);
+  return 0;
+}
+
+async function dev(rest) {
+  const app = rest.find(a => !a.startsWith("-")) || config.defaultScope();
+  if (!app) return fail("runner dev: which app? e.g. `runner dev acme.crm`", 2);
+  const base = config.apiBase();
+  if (rest.includes("--hosted")) {
+    const url = `${base}/?scope=${app}`;
+    console.error("Opening hosted app: " + url);
+    if (!rest.includes("--no-browser")) openUrl(url);
+    return 0;
+  }
+  const port = parseInt(opt(rest, "--port") || "8787", 10);
+  let sess;
+  try { sess = await api.post("/api/v1/dev/session", { scope: app }); }
+  catch (e) { return fail("runner dev: could not open a dev session: " + e.message); }
+  const cookie = `${sess.cookie_name}=${sess.cookie_value}`;
+  const upstream = new URL(base);
+  const server = http.createServer((req, res) => proxy(req, res, upstream, cookie));
+  server.listen(port, "127.0.0.1", () => {
+    const local = `http://127.0.0.1:${port}${sess.prefix || ""}/?scope=${app}`;
+    console.error(`runner dev: proxying ${app} → ${upstream.origin}`);
+    console.error(`  open  ${local}\n  (Ctrl-C to stop)`);
+    if (!rest.includes("--no-browser")) setTimeout(() => openUrl(local), 600);
+  });
+  return new Promise(() => {}); // serve until Ctrl-C
+}
+
+function proxy(req, res, upstream, cookie) {
+  const chunks = [];
+  req.on("data", c => chunks.push(c));
+  req.on("end", () => {
+    const headers = { ...req.headers, host: upstream.host };
+    headers.cookie = cookie + (req.headers.cookie ? "; " + req.headers.cookie : "");
+    delete headers["accept-encoding"];
+    const opts = { protocol: upstream.protocol, hostname: upstream.hostname,
+      port: upstream.port || (upstream.protocol === "https:" ? 443 : 80),
+      method: req.method, path: req.url, headers };
+    const lib = upstream.protocol === "https:" ? https : http;
+    const up = lib.request(opts, r => { res.writeHead(r.statusCode, r.headers); r.pipe(res); });
+    up.on("error", e => { res.writeHead(502); res.end("dev proxy error: " + e.message); });
+    if (chunks.length) up.write(Buffer.concat(chunks));
+    up.end();
+  });
+}
+
+function openUrl(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  import("node:child_process").then(cp => { try { cp.spawn(cmd, [url], { stdio: "ignore", detached: true }).unref(); } catch {} });
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (!argv.length || ["help", "-h", "--help"].includes(argv[0])) { console.log(HELP); return 0; }
+  const [cmd, ...rest] = argv;
+  if (["version", "--version", "-V"].includes(cmd)) { console.log("runner (@acsetra/runner) 0.1.0"); return 0; }
+  if (cmd === "signin" || cmd === "login") return signin(rest);
+  if (cmd === "logout" || cmd === "signout") { const c = config.loadUser(); delete c.token; config.saveUser(c); console.error("logged out"); return 0; }
+  if (cmd === "use") { if (!rest[0]) return fail("usage: runner use <slug>"); config.setProject({ workspace: rest[0] }); console.error("workspace -> " + rest[0]); return 0; }
+  if (cmd === "dev") return dev(rest);
+  if (cmd === "docs") { if (rest[0] === "pull") return docsPull(rest); return fail("usage: runner docs pull [-S scope]"); }
+
+  try {
+    if (cmd === "whoami") return emit(await api.get("/api/v1/whoami"));
+    if (cmd === "workspaces") { const u = opt(rest, "--use"); if (u) config.setProject({ workspace: u }); return emit(await api.get("/api/v1/workspaces")); }
+    if (cmd === "usage") return emit(await api.get("/api/v1/usage", { days: opt(rest, "--days") || "30" }));
+    if (cmd === "tokens") {
+      if (rest[0] === "new") return console.log(JSON.stringify(await api.post("/api/v1/tokens", { name: opt(rest, "--name") || "cli" }), null, 2));
+      if (rest[0] === "revoke" && rest[1]) return emit(await api.del("/api/v1/tokens/" + rest[1]));
+      return emit(await api.get("/api/v1/tokens"));
+    }
+    const [op, args] = toOp(cmd, rest);
+    emit(await api.postOp(op, args));
+    return 0;
+  } catch (e) {
+    if (e instanceof VerbError) return fail(e.message, 2);
+    if (e instanceof api.ApiError) return fail(e.message);
+    throw e;
+  }
+}
+
+main().then(c => process.exit(c || 0)).catch(e => { console.error("REJECTED: " + (e.stack || e.message)); process.exit(1); });

package/lib/api.js

@@ -0,0 +1,74 @@
+// HTTP layer — the Node mirror of acsetra_cli/api.py. Uses global fetch (Node 18+).
+import * as config from "./config.js";
+
+export class ApiError extends Error {
+  constructor(message, status = 0, detail = {}) {
+    super(message);
+    this.status = status;
+    this.detail = detail;
+  }
+}
+
+function headers(auth = true) {
+  const h = { "Content-Type": "application/json" };
+  if (auth) {
+    const tok = config.token();
+    if (!tok) throw new ApiError("not signed in — run `runner signin`", 401);
+    h["Authorization"] = "Bearer " + tok;
+    const ws = config.workspace();
+    if (ws) h["X-Runner-Workspace"] = ws;
+  }
+  return h;
+}
+
+async function check(resp) {
+  const text = await resp.text();
+  let body = {};
+  try { body = text ? JSON.parse(text) : {}; } catch { body = { error: text }; }
+  if (Math.floor(resp.status / 100) === 2) return body;
+  throw new ApiError(body.error || body.detail || text || resp.statusText, resp.status, body);
+}
+
+export async function postOp(op, args) {
+  const r = await fetch(config.apiBase() + "/api/v1/op", {
+    method: "POST", headers: headers(), body: JSON.stringify({ op, args }),
+  });
+  return check(r);
+}
+
+export async function get(path, params) {
+  const url = new URL(config.apiBase() + path);
+  for (const [k, v] of Object.entries(params || {})) url.searchParams.set(k, v);
+  const r = await fetch(url, { headers: headers() });
+  return check(r);
+}
+
+export async function post(path, body, auth = true) {
+  const r = await fetch(config.apiBase() + path, {
+    method: "POST", headers: headers(auth), body: JSON.stringify(body || {}),
+  });
+  return check(r);
+}
+
+export async function del(path) {
+  const r = await fetch(config.apiBase() + path, { method: "DELETE", headers: headers() });
+  return check(r);
+}
+
+// device flow (no bearer yet) — returns {status, body} without throwing on poll codes
+export async function deviceStart(tokenName = "cli") {
+  const r = await fetch(config.apiBase() + "/api/v1/auth/device/start", {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token_name: tokenName }),
+  });
+  return check(r);
+}
+export async function deviceToken(deviceCode) {
+  const r = await fetch(config.apiBase() + "/api/v1/auth/device/token", {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ device_code: deviceCode }),
+  });
+  let body = {};
+  try { body = await r.json(); } catch {}
+  return { status: r.status, body };
+}

package/lib/config.js

@@ -0,0 +1,40 @@
+// Config + credential resolution — the Node mirror of acsetra_cli/config.py.
+// Two stores: env > project (./.runner/config.json) > user (~/.config/acsetra/credentials).
+// The token only ever lives in the user store (chmod 600).
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const DEFAULT_API_BASE = "https://pen.acsetra.com";
+const USER_DIR = process.env.ACSETRA_HOME || path.join(os.homedir(), ".config", "acsetra");
+const CRED = path.join(USER_DIR, "credentials");
+const PROJ_DIR = ".runner";
+const PROJ = path.join(PROJ_DIR, "config.json");
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+export const loadUser = () => readJson(CRED);
+export const loadProject = () => readJson(PROJ);
+
+export function saveUser(data) {
+  fs.mkdirSync(USER_DIR, { recursive: true });
+  fs.writeFileSync(CRED, JSON.stringify(data, null, 2));
+  try { fs.chmodSync(CRED, 0o600); } catch {}
+}
+export function saveProject(data) {
+  fs.mkdirSync(PROJ_DIR, { recursive: true });
+  fs.writeFileSync(PROJ, JSON.stringify(data, null, 2));
+}
+export function setProject(kv) {
+  const cfg = loadProject();
+  for (const [k, v] of Object.entries(kv)) if (v != null) cfg[k] = v;
+  saveProject(cfg);
+  return cfg;
+}
+
+export const apiBase = () =>
+  (process.env.ACSETRA_API_BASE || loadProject().api_base || loadUser().api_base || DEFAULT_API_BASE).replace(/\/$/, "");
+export const token = () => process.env.ACSETRA_TOKEN || loadUser().token;
+export const workspace = () => process.env.ACSETRA_WORKSPACE || loadProject().workspace || loadUser().workspace;
+export const defaultScope = () => process.env.ACSETRA_SCOPE || loadProject().default_scope;

package/lib/verbs.js

@@ -0,0 +1,202 @@
+// The verb grammar — argv -> {op, args}. Node mirror of acsetra_cli/verbs.py.
+import fs from "node:fs";
+
+const JSON_ARGS = new Set(["meta", "schema", "decls", "tree", "props", "parts", "input",
+  "attrs", "config", "config_schema", "storage", "allow_hosts", "spec"]);
+const INT_ARGS = new Set(["ordinal", "rate", "timeout", "retries", "at", "max_bytes", "ttl_days", "days"]);
+const FLOAT_ARGS = new Set(["backoff"]);
+const BOOL_ARGS = new Set(["replace", "force", "keep", "probe", "enabled", "muted", "autoplay", "controls", "auth_flow"]);
+const PRIMARY_JSON = {
+  "set.put": "meta", "set.fetch_url": "meta", "set.declare_schema": "schema",
+  "css.set_rule": "decls", "component.set": "tree", "component.set_route": "props",
+  "behavior.attach": "config", "head.set": "attrs",
+};
+const POS = {
+  "set.create": ["code"], "set.put": ["set_code", "row_code"], "set.declare_schema": ["code"],
+  "set.fetch_url": ["set_code", "row_code", "url"], "set.remove_row": ["set_code", "row_code"],
+  "set.drop": ["set_code"], "set.describe": ["set_code"], "set.rows": ["set_code"],
+  "pipe.set": ["code"], "pipe.show": ["code"], "pipe.remove": ["code"],
+  "css.set_class": ["code"], "css.set_rule": ["class_code", "variant"], "css.clear_rule": ["class_code"],
+  "css.attach": ["class_code", "target"], "css.detach": ["code"], "css.describe": ["class_code"], "css.resolve": ["page"],
+  "asset.add": ["code", "kind"], "asset.attach": ["asset", "slot"], "asset.detach": ["code"],
+  "asset.describe": ["code"], "asset.resolve": ["page"],
+  "behavior.add": ["code"], "behavior.set_enabled": ["code", "enabled"], "behavior.remove": ["code"],
+  "behavior.attach": ["behavior_code", "target"], "behavior.set_attachment_enabled": ["code", "enabled"],
+  "behavior.detach": ["code"], "behavior.describe": ["code"],
+  "component.set": ["code"], "component.remove": ["code"], "component.set_route": ["code", "component"],
+  "component.remove_route": ["code"], "component.describe": ["code"],
+  "head.set": ["code"], "head.remove": ["code"],
+};
+const PLANES = new Set(["set", "css", "asset", "behavior", "component", "head"]);
+const SHORT = { w: "writes", k: "keys", u: "url", f: "body_from", H: "handler", X: "method", s: "spec", l: "label", i: "input" };
+
+export class VerbError extends Error {}
+
+function coerce(name, value) {
+  if (value == null) return null;
+  if (JSON_ARGS.has(name)) {
+    if (typeof value === "string" && value.startsWith("@")) return JSON.parse(fs.readFileSync(value.slice(1), "utf8"));
+    return typeof value === "string" ? JSON.parse(value) : value;
+  }
+  if (INT_ARGS.has(name)) return parseInt(value, 10);
+  if (FLOAT_ARGS.has(name)) return parseFloat(value);
+  if (BOOL_ARGS.has(name)) return ["1", "true", "yes", "on"].includes(String(value).toLowerCase());
+  return value;
+}
+
+function readBody(v) {
+  return v === "-" ? fs.readFileSync(0, "utf8") : v;
+}
+
+function walk(rest) {
+  const positionals = [], flags = {};
+  let i = 0;
+  while (i < rest.length) {
+    const tok = rest[i];
+    if (tok === "-S" || tok === "--scope") { flags.scope = rest[++i]; i++; continue; }
+    if (tok === "-b" || tok === "--body") { flags.__body = readBody(rest[++i]); i++; continue; }
+    if (tok === "--json") {
+      const blob = rest[++i]; i++;
+      const obj = blob.startsWith("@") ? JSON.parse(fs.readFileSync(blob.slice(1), "utf8")) : JSON.parse(blob);
+      flags.__json = Object.assign(flags.__json || {}, obj); continue;
+    }
+    if (tok.startsWith("--") || (tok.startsWith("-") && tok.length === 2 && !/\d/.test(tok[1]))) {
+      let name = tok.replace(/^-+/, "").replace(/-/g, "_");
+      name = SHORT[name] || name;
+      const nxt = i + 1 < rest.length ? rest[i + 1] : null;
+      if (BOOL_ARGS.has(name) && (nxt == null || nxt.startsWith("-") ||
+          !["true", "false", "1", "0", "yes", "no", "on", "off"].includes(nxt.toLowerCase()))) {
+        flags[name] = true; i++; continue;
+      }
+      if (nxt == null) throw new VerbError(`missing value for ${tok}`);
+      flags[name] = nxt; i += 2; continue;
+    }
+    positionals.push(tok); i++;
+  }
+  return { positionals, flags };
+}
+
+function assemble(op, positionals, flags) {
+  const args = {};
+  const names = POS[op] || [];
+  positionals.forEach((val, idx) => {
+    if (idx >= names.length) throw new VerbError(`too many positional args for \`${op}\``);
+    args[names[idx]] = coerce(names[idx], val);
+  });
+  if ("scope" in flags) { args.scope = flags.scope; delete flags.scope; }
+  if (flags.__json) {
+    const blob = flags.__json; delete flags.__json;
+    const prim = PRIMARY_JSON[op];
+    if (prim && !(prim in args)) args[prim] = blob;
+    else Object.assign(args, blob);
+  }
+  delete flags.__body;
+  for (const [k, v] of Object.entries(flags)) args[k] = coerce(k, v);
+  return args;
+}
+
+export function toOp(verb, rest) {
+  verb = verb.replace(/-/g, "_");
+  if (verb === "w" || verb === "work") return worker(rest);
+  if (verb === "op") {
+    if (!rest.length) throw new VerbError("usage: runner op <name> [--json '{…}'] [--flag value]");
+    const { positionals, flags } = walk(rest.slice(1));
+    const args = assemble(rest[0], positionals, flags);
+    if (flags.__body !== undefined) args.body = flags.__body;
+    return [rest[0], args];
+  }
+  if (verb === "inspect" || verb === "i") {
+    const { positionals, flags } = walk(rest);
+    const op = positionals.length ? "set.rows" : "set.list";
+    return [op, assemble(op, positionals, flags)];
+  }
+  if (verb === "ls") { const { flags } = walk(rest); return ["set.list", assemble("set.list", [], flags)]; }
+  if (verb === "pipe") {
+    if (rest.length && ["show", "list", "remove"].includes(rest[0])) {
+      const op = "pipe." + rest[0];
+      const { positionals, flags } = walk(rest.slice(1));
+      return [op, assemble(op, positionals, flags)];
+    }
+    const { positionals, flags } = walk(rest);
+    const args = assemble("pipe.set", positionals, flags);
+    if (typeof args.writes === "string") {
+      const [c, ...r] = args.writes.split(":"); args.writes = { code: c, label: r.join(":") || c };
+    }
+    return ["pipe.set", args];
+  }
+  if (verb === "pipes") { const { flags } = walk(rest); return ["pipe.list", assemble("pipe.list", [], flags)]; }
+  if (verb === "show") { const { positionals, flags } = walk(rest); return ["pipe.show", assemble("pipe.show", positionals, flags)]; }
+  if (verb === "read") {
+    const { positionals, flags } = walk(rest);
+    const args = { code: positionals[0] || flags.code };
+    if ("scope" in flags) args.scope = flags.scope;
+    return ["read", args];
+  }
+  if (verb === "run") {
+    const { positionals, flags } = walk(rest);
+    const args = { pipeline: positionals[0] || flags.pipeline };
+    if ("input" in flags) args.input = coerce("input", flags.input);
+    return ["run", args];
+  }
+  if (verb === "runs") { const { positionals } = walk(rest); return ["runs", { launch: positionals[0] }]; }
+  if (verb === "compile" || verb === "doctor") {
+    const { positionals, flags } = walk(rest);
+    const args = {};
+    if (positionals.length) args.scope = positionals[0];
+    if ("scope" in flags) args.scope = flags.scope;
+    return [verb === "compile" ? "bundle.compile" : "doctor.compile", args];
+  }
+  if (verb === "app") {
+    if (rest[0] === "create") {
+      const { positionals, flags } = walk(rest.slice(1));
+      const args = { name: positionals[0] };
+      if ("label" in flags) args.label = flags.label;
+      return ["app.create", args];
+    }
+    if (rest[0] === "list") return ["app.list", {}];
+    throw new VerbError("usage: runner app create <name> [--label L] | runner app list");
+  }
+  if (verb === "apps") return ["app.list", {}];
+  if (PLANES.has(verb)) {
+    if (!rest.length) throw new VerbError(`usage: runner ${verb} <subverb> …`);
+    let sub = rest[0].replace(/-/g, "_");
+    if (verb === "css") sub = ({ class: "set_class", rule: "set_rule" })[sub] || sub;
+    const op = `${verb}.${sub}`;
+    const { positionals, flags } = walk(rest.slice(1));
+    const args = assemble(op, positionals, flags);
+    if (flags.__body !== undefined) args.body = flags.__body;
+    return [op, args];
+  }
+  throw new VerbError(`unknown command '${verb}' — try \`runner help\``);
+}
+
+function worker(rest) {
+  if (rest.length < 2) throw new VerbError("usage: runner w <pipeline-code> <tier> [flags]");
+  const [code, tier] = rest;
+  const { flags } = walk(rest.slice(2));
+  const spec = {};
+  const body = flags.__body;
+  if (tier === "snippet") { if (!body) throw new VerbError("snippet worker needs -b <code|->"); spec.body = body; }
+  else if (tier === "internal") { if (!flags.handler) throw new VerbError("internal worker needs --handler"); spec.handler = flags.handler; }
+  else if (tier === "httpx") {
+    if (!flags.url) throw new VerbError("httpx worker needs --url");
+    spec.url = flags.url; spec.method = flags.method || "POST";
+    spec.keys = (flags.keys || "").split(",").map(s => s.trim()).filter(Boolean);
+    if (flags.body_from) spec.body_from = flags.body_from;
+  } else if (tier === "read") {
+    if (!flags.set) throw new VerbError("read worker needs --set CODE");
+    spec.set = flags.set; spec.mode = flags.mode || "latest";
+    for (const k of ["key", "scope", "as"]) if (flags[k]) spec[k] = flags[k];
+    if (flags.read_scope) spec.scope = flags.read_scope;
+  } else if (tier === "llm") {
+    spec.provider = flags.provider || "openai"; spec.user_from = flags.user_from || "ask";
+    for (const k of ["model", "system_from", "url", "response_path", "as"]) if (flags[k]) spec[k] = flags[k];
+    if (flags.keys) spec.keys = flags.keys.split(",").map(s => s.trim()).filter(Boolean);
+  }
+  if (flags.spec) Object.assign(spec, coerce("spec", flags.spec));
+  const args = { code, tier, spec };
+  if (flags.writes) args.writes = flags.writes;
+  if (flags.at) args.at = coerce("at", flags.at);
+  if (flags.scope) args.scope = flags.scope;
+  return ["pipe.add_worker", args];
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@acsetra/runner",
+  "version": "0.1.0",
+  "description": "Runner CLI — author and run hosted Runner apps from your terminal (the `runner` command).",
+  "keywords": ["runner", "acsetra", "cli", "agent", "low-code"],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "runner": "bin/runner.js",
+    "acsetra": "bin/runner.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": ["bin", "lib", "README.md"],
+  "homepage": "https://acsetra.com"
+}