@agentproto/relay 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy (ref.sh)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# @agentproto/relay
+
+A small, standalone companion service that lets **one** external HTTP webhook
+wake up **one** specific, pre-configured agentproto daemon session.
+
+This is generic OSS infrastructure. It has no knowledge of, and no code
+specific to, any particular external product, CRM, or messaging platform.
+Wiring this up to a specific external system (mapping that system's webhook
+payload into `{"text": "..."}`, handling its signature scheme, etc.) is
+integration work that happens outside this package — this package only knows
+how to accept `{"text": "..."}` and forward it to a daemon session.
+
+## Security model — read this before exposing it publicly
+
+This service is designed to run behind a public tunnel. The main risk of
+"webhook wakes up an agent" is a leaked or guessed credential letting an
+attacker inject prompts into *any* of your live sessions. This package's
+answer to that:
+
+- **Exactly one target session, fixed at startup.** The session id/name is
+  read once from `AGENTPROTO_RELAY_TARGET_SESSION` at process start. It is
+  **never** accepted as part of an inbound request — there is no `sessionId`
+  field anywhere in the `/relay/inbound` API. Even a fully leaked bearer
+  token only lets a caller wake up the one session the operator explicitly
+  chose to expose.
+- **Mandatory bearer token, constant-time compare.** `AGENTPROTO_RELAY_TOKEN`
+  is required — the process refuses to start without it. There is no
+  no-auth fallback, ever. The comparison uses an HMAC-blinded constant-time
+  compare (not `===`, not a naive `timingSafeEqual` on raw buffers) so a
+  network attacker can't use response-timing differences to recover the
+  token one byte at a time.
+- **Basic rate limiting.** A publicly reachable endpoint that triggers an LLM
+  turn is a real cost/abuse vector even behind a valid-looking token. See
+  below for the default and how to tune it.
+- **Inbound-only.** This service relays *into* a session. Getting output back
+  out is the target session's own job, using whatever tools/credentials it's
+  separately given — that's intentionally not this package's concern.
+
+## What it exposes
+
+### `POST /relay/inbound`
+
+Body is a flexible JSON object. The **only** field read is a top-level
+`text` string — everything else is ignored. This is deliberate: it makes the
+endpoint compatible with webhook payloads from arbitrary external senders
+(which typically include a `text`/`message`/`body` field buried among sender
+metadata this package has no reason to understand) without needing per-sender
+adapter code.
+
+Requires `Authorization: Bearer <AGENTPROTO_RELAY_TOKEN>`.
+
+On a valid, authenticated request:
+
+1. Confirms the configured target session exists and is alive via the
+   daemon's `GET /sessions/:id`.
+2. Delivers `text` to it via the configured delivery mode — either
+   `agent_prompt` (`POST /sessions/:id/prompt`, fire-and-forget) or
+   `terminal_input` (a WebSocket write to a PTY session's stdin).
+3. Returns `202 { ok: true, sessionId, via }` once the daemon has accepted
+   the message. This does **not** wait for the agent to finish its turn —
+   webhook senders often have short timeouts, and there's no reason to hold
+   the connection open for an entire LLM turn just to relay one message in.
+
+Error responses are plain JSON with an `error` code and a human-readable
+`message`: `401 unauthorized`, `429 rate_limited`, `400 missing_text` /
+`invalid_body`, `502 target_session_unavailable` / `relay_delivery_failed`.
+
+### `GET /relay/health`
+
+Trivial healthcheck. No auth required.
+
+## Configuration
+
+All via environment variables:
+
+| Variable | Required | Default | Meaning |
+| --- | --- | --- | --- |
+| `AGENTPROTO_RELAY_TARGET_SESSION` | yes | — | The id or name of the ONE session this relay may wake up. |
+| `AGENTPROTO_RELAY_TOKEN` | yes | — | Shared-secret bearer token for `/relay/inbound`. The process refuses to start if this is unset or empty. |
+| `AGENTPROTO_RELAY_TARGET_VIA` | no | `agent` | `agent` (deliver via `agent_prompt`) or `terminal` (deliver via `terminal_input`). |
+| `AGENTPROTO_DAEMON_URL` | no | `http://127.0.0.1:18790` | Base URL of the agentproto daemon to talk to. |
+| `AGENTPROTO_RELAY_RATE_LIMIT` | no | `20` | Max `/relay/inbound` requests allowed per rate-limit window. |
+| `AGENTPROTO_RELAY_RATE_WINDOW_MS` | no | `60000` | Rate-limit window size, in milliseconds. |
+
+The rate limit is **global**, not per-caller — this relay is designed for
+exactly one legitimate caller (whoever holds the token), so there's no
+per-IP bucketing to bypass or exhaust via header spoofing.
+
+## Running it
+
+```bash
+# from the monorepo root, after `pnpm install` + `pnpm build`
+AGENTPROTO_RELAY_TARGET_SESSION=my-session \
+AGENTPROTO_RELAY_TOKEN=$(openssl rand -hex 32) \
+node packages/relay/dist/cli.mjs --port 8790
+```
+
+Add `--tunnel` to also ask the daemon (via its `tunnel_create`/`/tunnels`
+REST route) to spawn a public cloudflared quick tunnel for `--port`, and
+print the resulting public URL:
+
+```bash
+AGENTPROTO_RELAY_TARGET_SESSION=my-session \
+AGENTPROTO_RELAY_TOKEN=$(openssl rand -hex 32) \
+node packages/relay/dist/cli.mjs --port 8790 --tunnel
+```
+
+```
+Public relay URL — paste this into whatever external system sends the webhook:
+  https://random-words-1234.trycloudflare.com/relay/inbound
+```
+
+That printed URL — `<tunnel-url>/relay/inbound` — is what you paste into
+whatever external system delivers the webhook. Without `--tunnel`, the relay
+just binds to `127.0.0.1:<port>` for local testing.
+
+## curl example
+
+```bash
+curl -X POST http://127.0.0.1:8790/relay/inbound \
+  -H "Authorization: Bearer $AGENTPROTO_RELAY_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "a customer just replied, take a look"}'
+```
+
+```json
+{"ok":true,"sessionId":"sess_abc12345","via":"agent"}
+```
+
+## Explicitly out of scope
+
+- Any specific external integration — mapping a particular product's webhook
+  shape into `{"text": "..."}`, verifying that product's signature scheme,
+  etc. That's integration-specific glue that lives outside this repo.
+- Outbound delivery. This is inbound-only: external webhook → wake a
+  session. Sending messages back out is the target session's own job.
+- Multi-session or dynamic target selection. Deliberately not supported —
+  see the security model above.

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.mjs

@@ -0,0 +1,456 @@
+#!/usr/bin/env node
+import { createServer } from 'http';
+import { readFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import WebSocket from 'ws';
+import { randomBytes, createHmac, timingSafeEqual } from 'crypto';
+
+/**
+ * @agentproto/relay v0.1.0-alpha
+ * Standalone webhook-to-session relay: one fixed target session, one bearer token.
+ */
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+var DEFAULT_DAEMON_URL = "http://127.0.0.1:18790";
+var DEFAULT_TARGET_VIA = "agent";
+var DEFAULT_RATE_LIMIT_MAX = 20;
+var DEFAULT_RATE_LIMIT_WINDOW_MS = 6e4;
+function loadConfigFromEnv(env = process.env) {
+  const targetSession = (env.AGENTPROTO_RELAY_TARGET_SESSION ?? "").trim();
+  if (!targetSession) {
+    throw new Error(
+      "AGENTPROTO_RELAY_TARGET_SESSION is required \u2014 set it to the id or name of the ONE session this relay is allowed to wake up. It is never accepted as a request parameter, by design."
+    );
+  }
+  const rawVia = (env.AGENTPROTO_RELAY_TARGET_VIA ?? DEFAULT_TARGET_VIA).trim();
+  if (rawVia !== "agent" && rawVia !== "terminal") {
+    throw new Error(
+      `AGENTPROTO_RELAY_TARGET_VIA must be "agent" or "terminal" (got "${rawVia}").`
+    );
+  }
+  const token = env.AGENTPROTO_RELAY_TOKEN ?? "";
+  if (!token) {
+    throw new Error(
+      "AGENTPROTO_RELAY_TOKEN is required \u2014 refusing to start without a shared secret. This service is designed to be exposed publicly; there is no no-auth fallback."
+    );
+  }
+  const daemonUrl = (env.AGENTPROTO_DAEMON_URL || DEFAULT_DAEMON_URL).replace(/\/+$/, "");
+  return {
+    targetSession,
+    targetVia: rawVia,
+    token,
+    daemonUrl,
+    rateLimit: {
+      max: parsePositiveInt(env.AGENTPROTO_RELAY_RATE_LIMIT, DEFAULT_RATE_LIMIT_MAX),
+      windowMs: parsePositiveInt(
+        env.AGENTPROTO_RELAY_RATE_WINDOW_MS,
+        DEFAULT_RATE_LIMIT_WINDOW_MS
+      )
+    }
+  };
+}
+function parsePositiveInt(raw, fallback) {
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+
+// src/daemon-client.ts
+var daemon_client_exports = {};
+__export(daemon_client_exports, {
+  checkSessionAlive: () => checkSessionAlive,
+  resolveDaemonToken: () => resolveDaemonToken,
+  sendAgentPrompt: () => sendAgentPrompt,
+  sendTerminalInput: () => sendTerminalInput
+});
+var DEAD_STATUSES = /* @__PURE__ */ new Set(["exited", "killed", "error"]);
+async function checkSessionAlive(daemonUrl, target, fetchImpl = fetch) {
+  let res;
+  try {
+    res = await fetchImpl(`${daemonUrl}/sessions/${encodeURIComponent(target)}`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `could not reach daemon at ${daemonUrl}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (res.status === 404) {
+    return { ok: false, reason: `no session "${target}" on the daemon` };
+  }
+  if (!res.ok) {
+    return { ok: false, reason: `daemon returned HTTP ${res.status} for GET /sessions/${target}` };
+  }
+  let desc;
+  try {
+    desc = await res.json();
+  } catch {
+    return { ok: false, reason: "daemon returned a non-JSON session descriptor" };
+  }
+  if (typeof desc.id !== "string") {
+    return { ok: false, reason: "daemon's session descriptor is missing an id" };
+  }
+  const status = typeof desc.status === "string" ? desc.status : void 0;
+  if (status && DEAD_STATUSES.has(status)) {
+    return { ok: false, id: desc.id, status, reason: `session "${target}" has status "${status}"` };
+  }
+  if (desc.processAlive === false) {
+    return { ok: false, id: desc.id, status, reason: `session "${target}" process is not alive` };
+  }
+  return { ok: true, id: desc.id, status };
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function resolveDaemonToken(daemonUrl, opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const homeDir = opts.homeDir ?? homedir();
+  const fromRegistry = await readRegistryToken(daemonUrl, homeDir);
+  if (fromRegistry) return fromRegistry;
+  return readWorkspaceToken(daemonUrl, fetchImpl);
+}
+async function readRegistryToken(daemonUrl, homeDir) {
+  let port;
+  try {
+    port = new URL(daemonUrl).port;
+  } catch {
+    return void 0;
+  }
+  if (!port) return void 0;
+  try {
+    const raw = await readFile(join(homeDir, ".agentproto", "daemons", `${port}.json`), "utf8");
+    const meta = JSON.parse(raw);
+    if (typeof meta.pid === "number" && !isPidAlive(meta.pid)) return void 0;
+    return typeof meta.token === "string" && meta.token ? meta.token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readWorkspaceToken(daemonUrl, fetchImpl) {
+  try {
+    const res = await fetchImpl(`${daemonUrl}/health`, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) return void 0;
+    const health = await res.json();
+    if (typeof health.workspace !== "string" || !health.workspace) return void 0;
+    const raw = await readFile(join(health.workspace, ".agentproto", "runtime.json"), "utf8");
+    const meta = JSON.parse(raw);
+    return typeof meta.token === "string" && meta.token ? meta.token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function sendAgentPrompt(daemonUrl, sessionId, text, token, fetchImpl = fetch) {
+  try {
+    const res = await fetchImpl(
+      `${daemonUrl}/sessions/${encodeURIComponent(sessionId)}/prompt?wait=false`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...token ? { authorization: `Bearer ${token}` } : {}
+        },
+        body: JSON.stringify({ prompt: text }),
+        signal: AbortSignal.timeout(15e3)
+      }
+    );
+    if (res.ok) return { ok: true, status: res.status };
+    return { ok: false, status: res.status, message: await describeErrorResponse(res) };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function describeErrorResponse(res) {
+  try {
+    const body = await res.json();
+    if (typeof body.message === "string") return body.message;
+    if (typeof body.error === "string") return body.error;
+    return JSON.stringify(body);
+  } catch {
+    return `HTTP ${res.status}`;
+  }
+}
+async function sendTerminalInput(daemonUrl, sessionId, text, token, timeoutMs = 1e4) {
+  const wsUrl = `${daemonUrl.replace(/^http/, "ws")}/sessions/${encodeURIComponent(sessionId)}/pty`;
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise(result);
+    };
+    const ws = new WebSocket(wsUrl, {
+      headers: token ? { authorization: `Bearer ${token}` } : {}
+    });
+    const timer = setTimeout(() => {
+      ws.terminate();
+      settle({ ok: false, message: "terminal_input: timed out connecting to the daemon" });
+    }, timeoutMs);
+    ws.once("open", () => {
+      ws.send(JSON.stringify({ kind: "input", text }));
+      ws.close(1e3);
+      settle({ ok: true });
+    });
+    ws.once("unexpected-response", (_req, res) => {
+      ws.terminate();
+      settle({
+        ok: false,
+        status: res.statusCode,
+        message: `terminal_input: daemon rejected the WebSocket upgrade with HTTP ${res.statusCode}`
+      });
+    });
+    ws.once("error", (err) => {
+      settle({ ok: false, message: err instanceof Error ? err.message : String(err) });
+    });
+  });
+}
+
+// src/rate-limiter.ts
+function createRateLimiter(opts) {
+  const { max, windowMs } = opts;
+  const now = opts.now ?? Date.now;
+  const timestamps = [];
+  return {
+    allow() {
+      const t = now();
+      const cutoff = t - windowMs;
+      while (timestamps.length > 0 && timestamps[0] <= cutoff) {
+        timestamps.shift();
+      }
+      if (timestamps.length >= max) return false;
+      timestamps.push(t);
+      return true;
+    }
+  };
+}
+function timingSafeEqualStrings(a, b) {
+  const key = randomBytes(32);
+  const digestA = createHmac("sha256", key).update(a, "utf8").digest();
+  const digestB = createHmac("sha256", key).update(b, "utf8").digest();
+  return timingSafeEqual(digestA, digestB);
+}
+
+// src/server.ts
+var MAX_BODY_BYTES = 1e6;
+function createRelayServer(opts) {
+  const daemonClient = opts.daemonClient ?? daemon_client_exports;
+  const rateLimiter = opts.rateLimiter ?? createRateLimiter(opts.config.rateLimit);
+  return createServer((req, res) => {
+    handleRequest(req, res, opts.config, daemonClient, rateLimiter).catch((err) => {
+      if (!res.headersSent) {
+        writeJson(res, 500, {
+          error: "internal_error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    });
+  });
+}
+async function handleRequest(req, res, config, daemonClient, rateLimiter) {
+  const url = new URL(req.url ?? "/", "http://relay.local");
+  if (url.pathname === "/relay/health" && req.method === "GET") {
+    writeJson(res, 200, { ok: true });
+    return;
+  }
+  if (url.pathname === "/relay/inbound" && req.method === "POST") {
+    await handleInbound(req, res, config, daemonClient, rateLimiter);
+    return;
+  }
+  writeJson(res, 404, { error: "not_found" });
+}
+async function handleInbound(req, res, config, daemonClient, rateLimiter) {
+  if (!rateLimiter.allow()) {
+    writeJson(res, 429, {
+      error: "rate_limited",
+      message: `Too many requests \u2014 limit is ${config.rateLimit.max} per ${config.rateLimit.windowMs}ms.`
+    });
+    return;
+  }
+  const authHeader = req.headers.authorization ?? "";
+  const expected = `Bearer ${config.token}`;
+  if (!timingSafeEqualStrings(authHeader, expected)) {
+    writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  let body;
+  try {
+    body = await readJsonBody(req, MAX_BODY_BYTES);
+  } catch (err) {
+    writeJson(res, 400, {
+      error: "invalid_body",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  if (body === INVALID_JSON) {
+    writeJson(res, 400, { error: "invalid_body", message: "Body must be valid JSON." });
+    return;
+  }
+  const text = body?.text;
+  if (typeof text !== "string" || text.length === 0) {
+    writeJson(res, 400, {
+      error: "missing_text",
+      message: "Body must include a non-empty top-level `text` string. All other fields are ignored."
+    });
+    return;
+  }
+  const alive = await daemonClient.checkSessionAlive(config.daemonUrl, config.targetSession);
+  if (!alive.ok || !alive.id) {
+    writeJson(res, 502, {
+      error: "target_session_unavailable",
+      message: alive.reason ?? "target session is not available"
+    });
+    return;
+  }
+  const token = await daemonClient.resolveDaemonToken(config.daemonUrl);
+  const result = config.targetVia === "terminal" ? await daemonClient.sendTerminalInput(config.daemonUrl, alive.id, text, token) : await daemonClient.sendAgentPrompt(config.daemonUrl, alive.id, text, token);
+  if (!result.ok) {
+    const status = result.status && result.status >= 400 && result.status < 500 ? result.status : 502;
+    writeJson(res, status, {
+      error: "relay_delivery_failed",
+      message: result.message ?? "delivery to the target session failed"
+    });
+    return;
+  }
+  writeJson(res, 202, { ok: true, sessionId: alive.id, via: config.targetVia });
+}
+function writeJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+var INVALID_JSON = /* @__PURE__ */ Symbol("invalid_json");
+function readJsonBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > maxBytes) {
+        reject(new Error(`request body exceeds ${maxBytes} bytes`));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve(null);
+        return;
+      }
+      try {
+        resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch {
+        resolve(INVALID_JSON);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  let port = 8790;
+  let tunnel = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--port") {
+      const value = argv[++i];
+      port = Number(value);
+    } else if (arg?.startsWith("--port=")) {
+      port = Number(arg.slice("--port=".length));
+    } else if (arg === "--tunnel") {
+      tunnel = true;
+    } else if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`invalid --port value \u2014 expected an integer 1-65535`);
+  }
+  return { port, tunnel };
+}
+function printHelp() {
+  console.log(
+    [
+      "agentproto-relay \u2014 wake one pre-configured agentproto session from an external webhook.",
+      "",
+      "Usage:",
+      "  agentproto-relay --port <port> [--tunnel]",
+      "",
+      "Options:",
+      "  --port <n>   Local port to bind (default 8790).",
+      "  --tunnel     Also spawn a public cloudflared quick tunnel for --port via the",
+      "               daemon's tunnel_create, and print the public /relay/inbound URL.",
+      "  --help       Show this message.",
+      "",
+      "Required env vars: AGENTPROTO_RELAY_TARGET_SESSION, AGENTPROTO_RELAY_TOKEN.",
+      "See the package README for the full list."
+    ].join("\n")
+  );
+}
+async function createPublicTunnel(daemonUrl, port) {
+  const res = await fetch(`${daemonUrl}/tunnels`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ targetPort: port, label: "agentproto-relay" })
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`failed to create tunnel: HTTP ${res.status} ${text}`);
+  }
+  const desc = await res.json();
+  if (typeof desc.publicUrl !== "string" || !desc.publicUrl) {
+    throw new Error(`daemon did not return a publicUrl: ${JSON.stringify(desc)}`);
+  }
+  return desc.publicUrl;
+}
+async function main() {
+  const { port, tunnel } = parseArgs(process.argv.slice(2));
+  const config = loadConfigFromEnv(process.env);
+  const server = createRelayServer({ config });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+  console.log(`agentproto-relay listening on http://127.0.0.1:${port}`);
+  console.log(`  target session : ${config.targetSession} (via ${config.targetVia})`);
+  console.log(`  daemon         : ${config.daemonUrl}`);
+  console.log(
+    `  rate limit     : ${config.rateLimit.max} requests / ${config.rateLimit.windowMs}ms`
+  );
+  if (tunnel) {
+    console.log("");
+    console.log(`creating public tunnel for port ${port}...`);
+    const publicUrl = await createPublicTunnel(config.daemonUrl, port);
+    console.log("");
+    console.log("Public relay URL \u2014 paste this into whatever external system sends the webhook:");
+    console.log(`  ${publicUrl}/relay/inbound`);
+    console.log("");
+  }
+  const shutdown = (signal) => {
+    console.log(`
+received ${signal}, shutting down...`);
+    server.close(() => process.exit(0));
+  };
+  process.once("SIGINT", () => shutdown("SIGINT"));
+  process.once("SIGTERM", () => shutdown("SIGTERM"));
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.mjs.map
+//# sourceMappingURL=cli.mjs.map