omniforge-daemon 1.0.0

package/README.md

@@ -0,0 +1,38 @@
+# omniforge-daemon
+
+Connects a computer to your [Omniforge](https://omniforge.noahzhang.dev) agent.
+
+```sh
+npx omniforge-daemon pair ABCD-1234   # code comes from the console's "Add device"
+```
+
+The daemon opens an **outbound** WebSocket — no ports to open, nothing
+inbound. It runs the commands your agent asks for and streams back the output.
+
+```sh
+npx omniforge-daemon           # run with saved credentials
+npx omniforge-daemon status    # show what's configured
+npx omniforge-daemon logout    # forget this machine's credentials
+```
+
+## Safety
+
+- Confined to `~/omniforge` unless started with `OMNIFORGE_UNSAFE=1`.
+- Credentials live in `~/.omniforge/credentials.json` (0600) and are scoped to
+  this one device; revoking it in the console cuts the connection immediately.
+- Approval mode (on by default) makes every command wait for a click in the
+  console before it runs.
+
+Zero dependencies, requires Node ≥ 21. Source: one file, ~300 lines — read it
+before you run it.
+
+## Environment
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `OMNIFORGE_ROOT` | `~/omniforge` | workspace the agent is confined to |
+| `OMNIFORGE_UNSAFE` | unset | `1` allows paths outside the workspace |
+| `OMNIFORGE_LABEL` | hostname | name shown in the console |
+| `OMNIFORGE_URL` | hosted deployment | point at your own self-hosted worker |
+
+MIT

package/omniforge.mjs

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+// Omniforge daemon — connects this computer to your Omniforge agent.
+// Zero dependencies; requires Node.js >= 21 (global WebSocket, global fetch).
+//
+//   npx omniforge-daemon pair ABCD-1234     pair this machine, then run
+//   npx omniforge-daemon                    run with saved credentials
+//   npx omniforge-daemon status             show what's configured
+//   npx omniforge-daemon logout             forget this machine's credentials
+//
+// Optional env:
+//   OMNIFORGE_URL     deployment to talk to (default: the hosted one)
+//   OMNIFORGE_ROOT    workspace the agent works in (default: ~/omniforge)
+//   OMNIFORGE_UNSAFE  set to 1 to allow commands/files outside the workspace
+//   OMNIFORGE_LABEL   name shown in the console (default: hostname)
+//
+// The credentials file is the only secret on disk. It is written 0600 and holds
+// a token scoped to this one device; revoking the device in the console makes
+// it useless immediately.
+
+import { spawn } from "node:child_process";
+import { hostname, userInfo, platform, release, homedir } from "node:os";
+import { mkdir, readFile, writeFile, readdir, stat, rm, chmod } from "node:fs/promises";
+import { resolve, dirname, join, sep } from "node:path";
+
+const VERSION = "1.0.0";
+const DEFAULT_URL = "https://omniforge.noahzhang.dev";
+const CONFIG_DIR = join(homedir(), ".omniforge");
+const CREDENTIALS = join(CONFIG_DIR, "credentials.json");
+const OUTPUT_CAP = 200_000;
+const CLOSE_REVOKED = 4001;
+
+const ROOT = resolve(process.env.OMNIFORGE_ROOT || join(homedir(), "omniforge"));
+const UNSAFE = process.env.OMNIFORGE_UNSAFE === "1";
+
+const log = (...args) => console.log("omniforge:", ...args);
+const die = (msg, code = 1) => {
+  console.error("omniforge:", msg);
+  process.exit(code);
+};
+
+// ---------------------------------------------------------------- credentials
+
+async function readCredentials() {
+  try {
+    return JSON.parse(await readFile(CREDENTIALS, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function writeCredentials(creds) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  await writeFile(CREDENTIALS, JSON.stringify(creds, null, 2), { mode: 0o600 });
+  await chmod(CREDENTIALS, 0o600);
+}
+
+async function clearCredentials() {
+  await rm(CREDENTIALS, { force: true });
+}
+
+// ---------------------------------------------------------------- workspace
+
+function confine(p) {
+  const abs = resolve(ROOT, p ?? ".");
+  if (!UNSAFE && abs !== ROOT && !abs.startsWith(ROOT + sep)) {
+    throw new Error(`path "${p}" escapes workspace root ${ROOT} (start with OMNIFORGE_UNSAFE=1 to allow)`);
+  }
+  return abs;
+}
+
+function cap(s) {
+  if (s.length <= OUTPUT_CAP) return { text: s, truncated: false };
+  return { text: s.slice(0, OUTPUT_CAP), truncated: true };
+}
+
+function runExec({ cmd, cwd, timeoutMs }) {
+  return new Promise((done) => {
+    let workdir;
+    try {
+      workdir = confine(cwd);
+    } catch (e) {
+      return done({ ok: false, error: e.message });
+    }
+    const child = spawn("bash", ["-lc", cmd], { cwd: workdir, env: process.env });
+    let out = "";
+    let err = "";
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGKILL");
+    }, Math.min(timeoutMs ?? 120_000, 280_000));
+    child.stdout.on("data", (d) => (out += d));
+    child.stderr.on("data", (d) => (err += d));
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      done({ ok: false, error: e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const o = cap(out);
+      const e = cap(err);
+      done({
+        ok: !killed && code === 0,
+        exitCode: killed ? -1 : code,
+        stdout: o.text,
+        stderr: killed ? e.text + "\n[killed: timeout]" : e.text,
+        truncated: o.truncated || e.truncated,
+      });
+    });
+  });
+}
+
+async function handle(msg) {
+  switch (msg.type) {
+    case "exec":
+      return runExec(msg);
+    case "read_file": {
+      const content = await readFile(confine(msg.path), "utf8");
+      const c = cap(content);
+      return { ok: true, content: c.text, truncated: c.truncated };
+    }
+    case "write_file": {
+      const abs = confine(msg.path);
+      await mkdir(dirname(abs), { recursive: true });
+      await writeFile(abs, msg.content ?? "", "utf8");
+      return { ok: true };
+    }
+    case "list_dir": {
+      const abs = confine(msg.path);
+      const names = await readdir(abs);
+      const entries = await Promise.all(
+        names.slice(0, 500).map(async (name) => {
+          try {
+            const s = await stat(resolve(abs, name));
+            return { name, type: s.isDirectory() ? "dir" : "file", size: s.size };
+          } catch {
+            return { name, type: "unknown", size: 0 };
+          }
+        }),
+      );
+      return { ok: true, entries };
+    }
+    default:
+      return { ok: false, error: `unknown request type "${msg.type}"` };
+  }
+}
+
+// ---------------------------------------------------------------- commands
+
+async function cmdPair(code, url) {
+  if (!code) die("usage: omniforge pair <CODE>   (get a code from the console's Add device button)");
+  const normalized = code.trim().toUpperCase();
+  log(`pairing with ${url}…`);
+
+  let res;
+  try {
+    res = await fetch(`${url}/machine/pair`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        code: normalized,
+        hostname: process.env.OMNIFORGE_LABEL || hostname(),
+        os: `${platform()} ${release()}`,
+        root: ROOT,
+        version: VERSION,
+      }),
+    });
+  } catch (e) {
+    die(`could not reach ${url}: ${e.message}`);
+  }
+
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) die(body.error || `pairing failed (HTTP ${res.status})`);
+
+  await writeCredentials({ url, deviceId: body.deviceId, deviceToken: body.deviceToken, label: body.label });
+  log(`paired as "${body.label}". Credentials saved to ${CREDENTIALS} (0600).`);
+  await cmdRun();
+}
+
+async function cmdStatus() {
+  const creds = await readCredentials();
+  console.log(`omniforge-daemon ${VERSION}`);
+  console.log(`  workspace:   ${ROOT}${UNSAFE ? "  (UNSAFE: confinement off)" : ""}`);
+  console.log(`  credentials: ${creds ? CREDENTIALS : "none — run: omniforge pair <CODE>"}`);
+  if (creds) {
+    console.log(`  deployment:  ${creds.url}`);
+    console.log(`  label:       ${creds.label}`);
+    console.log(`  device id:   ${creds.deviceId}`);
+  }
+}
+
+async function cmdLogout() {
+  await clearCredentials();
+  log("credentials removed. This machine can no longer connect until you pair it again.");
+}
+
+/**
+ * Trade the stored device token for a 60-second ticket. A 401 here is terminal:
+ * it means the device was revoked from the console, so we stop instead of
+ * hammering the endpoint forever.
+ */
+async function fetchTicket(creds) {
+  const res = await fetch(`${creds.url}/machine/ticket`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${creds.deviceToken}` },
+  });
+  if (res.status === 401) {
+    await clearCredentials();
+    die("this device has been revoked from the console. Pair again with: omniforge pair <CODE>");
+  }
+  if (!res.ok) throw new Error(`ticket request failed (HTTP ${res.status})`);
+  return res.json();
+}
+
+async function cmdRun() {
+  const creds = await readCredentials();
+  if (!creds) die("no credentials. Get a code from the console and run: omniforge pair <CODE>");
+
+  await mkdir(ROOT, { recursive: true });
+  let backoff = 1000;
+  let stopped = false;
+
+  const connect = async () => {
+    if (stopped) return;
+    let ticket;
+    try {
+      ticket = await fetchTicket(creds);
+    } catch (e) {
+      log(`${e.message}; retrying in ${Math.round(backoff / 1000)}s`);
+      setTimeout(connect, backoff);
+      backoff = Math.min(backoff * 2, 30_000);
+      return;
+    }
+
+    const wsUrl =
+      creds.url.replace(/^http/, "ws").replace(/\/$/, "") +
+      `/machine/ws?ticket=${encodeURIComponent(ticket.ticket)}`;
+
+    log(
+      `connecting as "${ticket.label}" (workspace ${ROOT}${UNSAFE ? ", UNSAFE mode" : ""}` +
+        `${ticket.approvalMode ? ", approval required" : ""})`,
+    );
+    const ws = new WebSocket(wsUrl);
+    let pingTimer;
+
+    ws.onopen = () => {
+      backoff = 1000;
+      log("connected");
+      ws.send(
+        JSON.stringify({
+          type: "hello",
+          host: hostname(),
+          user: userInfo().username,
+          root: ROOT,
+          version: VERSION,
+        }),
+      );
+      pingTimer = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) ws.send('{"type":"ping"}');
+      }, 25_000);
+    };
+
+    ws.onmessage = async (event) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (msg.type === "pong" || !msg.id) return;
+      log(`${msg.type}${msg.cmd ? ` $ ${msg.cmd}` : msg.path ? ` ${msg.path}` : ""}`);
+      let result;
+      try {
+        result = await handle(msg);
+      } catch (e) {
+        result = { ok: false, error: e instanceof Error ? e.message : String(e) };
+      }
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "result", id: msg.id, ...result }));
+      }
+    };
+
+    ws.onclose = async (event) => {
+      clearInterval(pingTimer);
+      if (event.code === CLOSE_REVOKED) {
+        stopped = true;
+        await clearCredentials();
+        die("this device was revoked from the console. Pair again with: omniforge pair <CODE>");
+      }
+      log(`disconnected, retrying in ${Math.round(backoff / 1000)}s`);
+      setTimeout(connect, backoff);
+      backoff = Math.min(backoff * 2, 30_000);
+    };
+    ws.onerror = () => {};
+  };
+
+  connect();
+}
+
+// ---------------------------------------------------------------- entrypoint
+
+const [command, ...rest] = process.argv.slice(2);
+const urlFlagIndex = rest.indexOf("--url");
+const urlFromFlag = urlFlagIndex >= 0 ? rest[urlFlagIndex + 1] : null;
+const BASE = (urlFromFlag || process.env.OMNIFORGE_URL || DEFAULT_URL).replace(/\/$/, "");
+
+process.on("SIGINT", () => {
+  console.log("\nomniforge: bye");
+  process.exit(0);
+});
+
+switch (command) {
+  case "pair":
+    await cmdPair(rest[0], BASE);
+    break;
+  case "status":
+    await cmdStatus();
+    break;
+  case "logout":
+    await cmdLogout();
+    break;
+  case undefined:
+  case "run":
+    await cmdRun();
+    break;
+  default:
+    die(`unknown command "${command}". Try: pair <CODE> | run | status | logout`);
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "omniforge-daemon",
+  "version": "1.0.0",
+  "description": "Connect a computer to your Omniforge agent. Opens an outbound WebSocket — no ports, no inbound access.",
+  "keywords": ["omniforge", "agent", "cloudflare", "daemon"],
+  "license": "MIT",
+  "type": "module",
+  "bin": { "omniforge": "./omniforge.mjs" },
+  "files": ["omniforge.mjs", "README.md"],
+  "engines": { "node": ">=21" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iujab/omniforge.git",
+    "directory": "packages/daemon"
+  },
+  "homepage": "https://omniforge.noahzhang.dev"
+}