agent-relay-server 0.3.12 → 0.4.1

package/src/cli.ts

@@ -0,0 +1,217 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import {
+  createDaemonPlan,
+  detectDaemonEnvironment,
+  executeDaemonPlan,
+  formatDaemonPlan,
+  type DaemonAction,
+  type DaemonScope,
+} from "./daemon";
+import {
+  createSetupPlan,
+  executeSetupPlan,
+  formatSetupPlan,
+  pathExists,
+} from "./setup";
+import { VERSION } from "./config";
+
+const HELP = `
+agent-relay ${VERSION}
+
+Usage:
+  agent-relay [start]
+  agent-relay setup [--yes] [--dry-run] [--force] [--env-file PATH] [--host HOST] [--port PORT] [--db-path PATH] [--token TOKEN|--no-token]
+  agent-relay daemon <install|uninstall|start|stop|restart|enable|disable|status|logs> [options]
+  agent-relay --help
+
+Daemon options:
+  --env-file PATH   Env file sourced by the daemon (default: platform user config dir)
+  --binary PATH     Stable agent-relay binary/script path for the service
+  --name NAME       Service name (default: agent-relay)
+  --host HOST       Display/listen host for generated plan (default: 127.0.0.1)
+  --port PORT       Display/listen port for generated plan (default: 4850)
+  --user|--system   User service by default, system service when explicitly requested
+  --enable          Enable service at login/boot during install
+  --start           Start service after install
+  --dry-run         Print the plan without writing files or running service commands
+  --yes             Skip confirmation prompts
+  --force           Overwrite/remove managed-file guardrails
+  --json            Print structured output
+`.trim();
+
+const DAEMON_ACTIONS = new Set<DaemonAction>([
+  "install",
+  "uninstall",
+  "start",
+  "stop",
+  "restart",
+  "enable",
+  "disable",
+  "status",
+  "logs",
+]);
+
+export async function handleCli(args: string[]): Promise<"start" | "handled"> {
+  const command = args[0];
+  if (!command || command === "start") return "start";
+  if (command === "--help" || command === "-h" || command === "help") {
+    console.log(HELP);
+    return "handled";
+  }
+  if (command === "--version" || command === "-v") {
+    console.log(VERSION);
+    return "handled";
+  }
+  if (command === "setup" || command === "init") {
+    await handleSetupCommand(args.slice(1));
+    return "handled";
+  }
+  if (command === "daemon") {
+    await handleDaemonCommand(args.slice(1));
+    return "handled";
+  }
+  throw new Error(`Unknown command "${command}". Run agent-relay --help.`);
+}
+
+async function handleSetupCommand(args: string[]): Promise<void> {
+  let envFile: string | undefined;
+  let host: string | undefined;
+  let port: number | undefined;
+  let dbPath: string | undefined;
+  let token: string | undefined;
+  let generateToken = true;
+  let dryRun = false;
+  let force = false;
+  let yes = false;
+  let json = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--env-file" && i + 1 < args.length) envFile = args[++i];
+    else if (arg === "--host" && i + 1 < args.length) host = args[++i];
+    else if (arg === "--port" && i + 1 < args.length) port = parseInt(args[++i]!, 10);
+    else if (arg === "--db-path" && i + 1 < args.length) dbPath = args[++i];
+    else if (arg === "--token" && i + 1 < args.length) token = args[++i];
+    else if (arg === "--generate-token") generateToken = true;
+    else if (arg === "--no-token") generateToken = false;
+    else if (arg === "--dry-run") dryRun = true;
+    else if (arg === "--force") force = true;
+    else if (arg === "--yes") yes = true;
+    else if (arg === "--json") json = true;
+    else throw new Error(`Unknown setup option "${arg}"`);
+  }
+
+  const plan = createSetupPlan({
+    ...(envFile ? { envFile } : {}),
+    ...(host ? { host } : {}),
+    ...(port !== undefined ? { port } : {}),
+    ...(dbPath ? { dbPath } : {}),
+    ...(token ? { token } : {}),
+    generateToken,
+    force,
+  });
+
+  if (!dryRun && !yes && await pathExists(plan.envFile)) {
+    const ok = await confirm(`Overwrite ${plan.envFile}?`);
+    if (!ok) {
+      console.log("Setup cancelled.");
+      return;
+    }
+  }
+
+  const result = await executeSetupPlan(plan, { dryRun, force });
+  if (json) console.log(JSON.stringify({ plan, output: result }, null, 2));
+  else console.log(dryRun ? formatSetupPlan(plan) : result);
+}
+
+async function handleDaemonCommand(args: string[]): Promise<void> {
+  const action = parseDaemonAction(args[0]);
+  let name: string | undefined;
+  let envFile: string | undefined;
+  let port: number | undefined;
+  let host: string | undefined;
+  let scope: DaemonScope | undefined;
+  let binaryPath: string | undefined;
+  let start = false;
+  let enable = false;
+  let dryRun = false;
+  let force = false;
+  let yes = false;
+  let json = false;
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--name" && i + 1 < args.length) name = args[++i];
+    else if (arg === "--env-file" && i + 1 < args.length) envFile = args[++i];
+    else if (arg === "--port" && i + 1 < args.length) port = parseInt(args[++i]!, 10);
+    else if (arg === "--host" && i + 1 < args.length) host = args[++i];
+    else if (arg === "--user") scope = "user";
+    else if (arg === "--system") scope = "system";
+    else if (arg === "--binary" && i + 1 < args.length) binaryPath = args[++i];
+    else if (arg === "--start") start = true;
+    else if (arg === "--enable") enable = true;
+    else if (arg === "--dry-run") dryRun = true;
+    else if (arg === "--force") force = true;
+    else if (arg === "--yes") yes = true;
+    else if (arg === "--json") json = true;
+    else throw new Error(`Unknown daemon option "${arg}"`);
+  }
+
+  if (action === "install" && !dryRun && !envFile && !(await pathExists(createSetupPlan().envFile))) {
+    const setupPlan = createSetupPlan({
+      ...(host ? { host } : {}),
+      ...(port !== undefined ? { port } : {}),
+    });
+    const ok = yes || await confirm(`Create daemon env file at ${setupPlan.envFile}?`);
+    if (!ok) throw new Error("Daemon install needs an env file. Run `agent-relay setup` first.");
+    console.log(await executeSetupPlan(setupPlan, { force }));
+  }
+
+  const env = await detectDaemonEnvironment();
+  const plan = createDaemonPlan({
+    action,
+    ...(name ? { name } : {}),
+    ...(envFile ? { envFile } : {}),
+    ...(port !== undefined ? { port } : {}),
+    ...(host ? { host } : {}),
+    ...(scope ? { scope } : {}),
+    ...(binaryPath ? { binaryPath } : {}),
+    start,
+    enable,
+  }, env);
+
+  if (!dryRun && !json && (action === "install" || action === "uninstall") && !yes) {
+    const ok = await confirm(
+      action === "install"
+        ? `Install ${plan.kind} ${plan.scope} daemon "${plan.name}"?`
+        : `Uninstall daemon "${plan.name}"?`,
+    );
+    if (!ok) {
+      console.log("Daemon command cancelled.");
+      return;
+    }
+  }
+
+  const result = await executeDaemonPlan(plan, { dryRun, force });
+  if (json) console.log(JSON.stringify({ plan: result.plan, output: result.output }, null, 2));
+  else console.log(dryRun ? formatDaemonPlan(plan) : result.output);
+}
+
+function parseDaemonAction(value: string | undefined): DaemonAction {
+  if (!value || !DAEMON_ACTIONS.has(value as DaemonAction)) {
+    throw new Error("Usage: agent-relay daemon <install|uninstall|start|stop|restart|enable|disable|status|logs> [options]");
+  }
+  return value as DaemonAction;
+}
+
+async function confirm(message: string): Promise<boolean> {
+  if (!input.isTTY) return false;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    rl.close();
+  }
+}

package/src/config.ts

@@ -23,6 +23,44 @@ export const REAP_INTERVAL_MS = envPositiveInt("REAP_INTERVAL_MS", 60_000); // r
 
 // Max body size for any POST/PATCH request (64 KiB).
 export const MAX_BODY_BYTES = 64 * 1024;
+export const INTEGRATION_RATE_LIMIT_PER_MINUTE = envPositiveInt("AGENT_RELAY_INTEGRATION_RATE_LIMIT_PER_MINUTE", 120);
+
+export const AUTH_TOKEN = process.env.AGENT_RELAY_TOKEN || "";
+export const CORS_ORIGINS = (process.env.AGENT_RELAY_CORS_ORIGINS || "")
+  .split(",")
+  .map((origin) => origin.trim())
+  .filter(Boolean);
+
+export type IntegrationTokenConfig = {
+  name: string;
+  token: string;
+  scopes: string[];
+  targets?: string[];
+  channels?: string[];
+  callbackUrl?: string;
+};
+
+export function getIntegrationTokens(): IntegrationTokenConfig[] {
+  const raw = process.env.AGENT_RELAY_INTEGRATIONS;
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .filter((item): item is Record<string, unknown> => typeof item === "object" && item !== null)
+      .map((item) => ({
+        name: typeof item.name === "string" ? item.name : "",
+        token: typeof item.token === "string" ? item.token : "",
+        scopes: Array.isArray(item.scopes) ? item.scopes.filter((scope): scope is string => typeof scope === "string") : [],
+        targets: Array.isArray(item.targets) ? item.targets.filter((target): target is string => typeof target === "string") : undefined,
+        channels: Array.isArray(item.channels) ? item.channels.filter((channel): channel is string => typeof channel === "string") : undefined,
+        callbackUrl: typeof item.callbackUrl === "string" ? item.callbackUrl : undefined,
+      }))
+      .filter((item) => item.name && item.token);
+  } catch {
+    return [];
+  }
+}
 
 // Default capabilities for session-start hook when AGENT_RELAY_CAPS is unset.
 export const DEFAULT_CAPABILITIES = ["chat"];