agent-relay-server 0.9.0 → 0.10.0

package/public/manifest.webmanifest

@@ -2,9 +2,9 @@
   "name": "Agent Relay",
   "short_name": "Relay",
   "description": "Local control panel for Agent Relay agents, channels, tasks, and messages.",
-  "id": "/",
-  "start_url": "/",
-  "scope": "/",
+  "id": "./",
+  "start_url": "./",
+  "scope": "./",
   "display": "standalone",
   "background_color": "#0d1117",
   "theme_color": "#0d1117",
@@ -12,19 +12,19 @@
   "categories": ["developer", "productivity", "utilities"],
   "icons": [
     {
-      "src": "/icons/agent-relay.svg",
+      "src": "icons/agent-relay.svg",
       "sizes": "any",
       "type": "image/svg+xml",
       "purpose": "any maskable"
     },
     {
-      "src": "/icons/agent-relay-192.png",
+      "src": "icons/agent-relay-192.png",
       "sizes": "192x192",
       "type": "image/png",
       "purpose": "any maskable"
     },
     {
-      "src": "/icons/agent-relay-512.png",
+      "src": "icons/agent-relay-512.png",
       "sizes": "512x512",
       "type": "image/png",
       "purpose": "any maskable"

package/public/sw.js

@@ -1,12 +1,14 @@
 const CACHE_NAME = "agent-relay-dashboard-v1";
+const scopeUrl = new URL(self.registration.scope);
+const scopePath = scopeUrl.pathname.endsWith("/") ? scopeUrl.pathname : `${scopeUrl.pathname}/`;
+const appUrl = (path) => new URL(path, self.registration.scope).toString();
 const APP_SHELL = [
-  "/",
-  "/index.html",
-  "/dashboard.js",
-  "/manifest.webmanifest",
-  "/icons/agent-relay.svg",
-  "/icons/agent-relay-192.png",
-  "/icons/agent-relay-512.png",
+  appUrl("./"),
+  appUrl("index.html"),
+  appUrl("manifest.webmanifest"),
+  appUrl("icons/agent-relay.svg"),
+  appUrl("icons/agent-relay-192.png"),
+  appUrl("icons/agent-relay-512.png"),
 ];
 
 self.addEventListener("install", (event) => {
@@ -31,7 +33,11 @@ self.addEventListener("fetch", (event) => {
   const request = event.request;
   const url = new URL(request.url);
 
-  if (request.method !== "GET" || url.origin !== self.location.origin || url.pathname.startsWith("/api/")) {
+  if (request.method !== "GET" || url.origin !== self.location.origin || !url.pathname.startsWith(scopePath)) {
+    return;
+  }
+
+  if (url.pathname.startsWith(`${scopePath}api/`)) {
     return;
   }
 
@@ -42,7 +48,7 @@ self.addEventListener("fetch", (event) => {
   event.respondWith(
     fetch(request)
       .then((response) => {
-        if (response.ok && APP_SHELL.includes(url.pathname === "/" ? "/" : url.pathname)) {
+        if (response.ok && APP_SHELL.includes(url.href)) {
           const copy = response.clone();
           caches.open(CACHE_NAME).then((cache) => cache.put(request, copy));
         }
@@ -51,7 +57,7 @@ self.addEventListener("fetch", (event) => {
       .catch(async () => {
         const cached = await caches.match(request);
         if (cached) return cached;
-        if (request.mode === "navigate") return caches.match("/index.html");
+        if (request.mode === "navigate") return caches.match(appUrl("index.html"));
         throw new Error("offline");
       }),
   );

package/recipes/code-review.yaml

@@ -0,0 +1,26 @@
+name: Code Review
+description: Three agents review code from architecture, security, and test angles.
+version: "1.0"
+agents:
+  - role: lead-reviewer
+    provider: claude
+    capabilities: [review, architecture]
+    label: lead reviewer
+    approvalMode: guarded
+    prompt: Review architecture, maintainability, and release risk.
+  - role: security-reviewer
+    provider: claude
+    capabilities: [review, security]
+    label: security reviewer
+    approvalMode: guarded
+    prompt: Review authentication, authorization, secrets, and data handling.
+  - role: test-reviewer
+    provider: codex
+    capabilities: [review, testing]
+    label: test reviewer
+    approvalMode: guarded
+    prompt: Review test coverage and failure modes.
+workflow:
+  trigger: cap:review
+  fanOut: all
+  collect: lead-reviewer

package/recipes/debug.yaml

@@ -0,0 +1,20 @@
+name: Debug
+description: Investigator and fixer agents isolate and patch a bug.
+version: "1.0"
+agents:
+  - role: investigator
+    provider: claude
+    capabilities: [debug, analysis]
+    label: bug investigator
+    approvalMode: guarded
+    prompt: Reproduce the bug and identify the failing path.
+  - role: fixer
+    provider: codex
+    capabilities: [debug, code]
+    label: bug fixer
+    approvalMode: guarded
+    prompt: Implement the smallest safe fix and verify it.
+workflow:
+  trigger: cap:debug
+  fanOut: first
+  collect: investigator

package/recipes/feature.yaml

@@ -0,0 +1,26 @@
+name: Feature
+description: Planner plus two implementers for feature work.
+version: "1.0"
+agents:
+  - role: planner
+    provider: claude
+    capabilities: [planning, architecture]
+    label: feature planner
+    approvalMode: read-only
+    prompt: Map the change and split implementation safely.
+  - role: implementer-a
+    provider: codex
+    capabilities: [implementation]
+    label: implementer a
+    approvalMode: guarded
+    prompt: Implement the assigned feature slice.
+  - role: implementer-b
+    provider: codex
+    capabilities: [implementation]
+    label: implementer b
+    approvalMode: guarded
+    prompt: Implement an independent feature slice.
+workflow:
+  trigger: cap:feature
+  fanOut: all
+  collect: planner

package/recipes/refactor.yaml

@@ -0,0 +1,20 @@
+name: Refactor
+description: Analyzer and refactorer agents improve structure safely.
+version: "1.0"
+agents:
+  - role: analyzer
+    provider: claude
+    capabilities: [refactor, analysis]
+    label: refactor analyzer
+    approvalMode: read-only
+    prompt: Map dependents and identify safe refactor boundaries.
+  - role: refactorer
+    provider: codex
+    capabilities: [refactor, implementation]
+    label: refactorer
+    approvalMode: guarded
+    prompt: Apply the refactor and keep behavior unchanged.
+workflow:
+  trigger: cap:refactor
+  fanOut: first
+  collect: analyzer

package/recipes/test.yaml

@@ -0,0 +1,20 @@
+name: Test
+description: Test writer and verifier agents improve coverage and run checks.
+version: "1.0"
+agents:
+  - role: test-writer
+    provider: codex
+    capabilities: [testing, implementation]
+    label: test writer
+    approvalMode: guarded
+    prompt: Add focused tests for the target behavior.
+  - role: verifier
+    provider: claude
+    capabilities: [testing, review]
+    label: test verifier
+    approvalMode: read-only
+    prompt: Verify tests are meaningful and not overfit.
+workflow:
+  trigger: cap:test
+  fanOut: all
+  collect: verifier

package/runner/src/adapter.ts

@@ -0,0 +1,69 @@
+import type { Message } from "agent-relay-sdk";
+
+export type SemanticStatus = "idle" | "busy" | "offline" | "error";
+
+export interface ProviderConfig {
+  command: string;
+  defaultArgs: string[];
+  env: Record<string, string>;
+  pluginDirs: string[];
+  defaultCapabilities: string[];
+  defaultApprovalMode: string;
+  defaultTags: string[];
+  headless: {
+    tmuxPrefix: string;
+    shutdownTimeoutMs: number;
+  };
+}
+
+export interface RunnerSpawnConfig {
+  provider: string;
+  runnerId: string;
+  instanceId: string;
+  agentId: string;
+  relayUrl: string;
+  cwd: string;
+  headless: boolean;
+  approvalMode: string;
+  label?: string;
+  prompt?: string;
+  providerArgs: string[];
+  providerConfig: ProviderConfig;
+  env: Record<string, string>;
+  controlPort: number;
+  monitor?: {
+    deliver(messages: Message[]): Promise<number[]>;
+  };
+  [key: string]: unknown;
+}
+
+export interface SpawnArgs {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+}
+
+export interface ManagedProcess {
+  pid?: number;
+  process?: Bun.Subprocess;
+  meta?: Record<string, unknown>;
+}
+
+export interface ProviderAdapter {
+  provider: string;
+  spawn(config: RunnerSpawnConfig): Promise<ManagedProcess>;
+  shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void>;
+  deliver(process: ManagedProcess, messages: Message[]): Promise<void>;
+  onStatusChange(cb: (status: SemanticStatus) => void): void;
+  buildSpawnArgs(config: RunnerSpawnConfig, providerConfig: ProviderConfig): SpawnArgs;
+}
+
+export function providerMessageText(messages: Message[]): string {
+  return messages
+    .map((message) => {
+      const subject = message.subject ? `Subject: ${message.subject}\n` : "";
+      return `[relay message #${message.id} from ${message.from}]\n${subject}${message.body}`;
+    })
+    .join("\n\n");
+}

package/runner/src/config.ts

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join, resolve } from "node:path";
+import type { ProviderConfig } from "./adapter";
+
+interface GlobalRunnerConfig {
+  relayUrl: string;
+  token?: string;
+  defaultCwd: string;
+}
+
+interface LoadedProviderConfig extends ProviderConfig {
+  path: string;
+}
+
+const DEFAULT_RELAY_URL = "http://127.0.0.1:4850";
+
+function agentRelayHome(): string {
+  return process.env.AGENT_RELAY_HOME || join(homedir(), ".agent-relay");
+}
+
+function providersDir(home = agentRelayHome()): string {
+  return join(home, "providers");
+}
+
+export function defaultProviderConfig(provider: string): ProviderConfig {
+  const command = provider === "claude" ? "claude-rig" : provider;
+  return {
+    command,
+    defaultArgs: provider === "claude" ? ["--dangerously-skip-permissions"] : [],
+    env: {},
+    pluginDirs: [],
+    defaultCapabilities: ["chat", "code", "review"],
+    defaultApprovalMode: "guarded",
+    defaultTags: [],
+    headless: {
+      tmuxPrefix: `${provider}-relay`,
+      shutdownTimeoutMs: 10_000,
+    },
+  };
+}
+
+export function loadGlobalConfig(home = agentRelayHome()): GlobalRunnerConfig {
+  const path = join(home, "config.json");
+  const parsed = readJson(path);
+  return {
+    relayUrl: stringValue(parsed.relayUrl) ?? process.env.AGENT_RELAY_URL ?? DEFAULT_RELAY_URL,
+    token: stringValue(parsed.token) ?? process.env.AGENT_RELAY_TOKEN,
+    defaultCwd: stringValue(parsed.defaultCwd) ?? process.cwd(),
+  };
+}
+
+export function loadProviderConfig(provider: string, home = agentRelayHome()): LoadedProviderConfig {
+  const path = join(providersDir(home), `${provider}.json`);
+  const raw = readJson(path);
+  const defaults = defaultProviderConfig(provider);
+  return {
+    path,
+    command: stringValue(raw.command) ?? defaults.command,
+    defaultArgs: stringArray(raw.defaultArgs) ?? defaults.defaultArgs,
+    env: stringRecord(raw.env) ?? defaults.env,
+    pluginDirs: stringArray(raw.pluginDirs) ?? defaults.pluginDirs,
+    defaultCapabilities: stringArray(raw.defaultCapabilities) ?? defaults.defaultCapabilities,
+    defaultApprovalMode: stringValue(raw.defaultApprovalMode) ?? defaults.defaultApprovalMode,
+    defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
+    headless: {
+      tmuxPrefix: stringValue(recordValue(raw.headless).tmuxPrefix) ?? defaults.headless.tmuxPrefix,
+      shutdownTimeoutMs: positiveInteger(recordValue(raw.headless).shutdownTimeoutMs) ?? defaults.headless.shutdownTimeoutMs,
+    },
+  };
+}
+
+export function writeProviderConfig(provider: string, config: ProviderConfig, home = agentRelayHome()): LoadedProviderConfig {
+  const dir = providersDir(home);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${provider}.json`);
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  return { ...config, path };
+}
+
+export function providerConfigPublic(config: LoadedProviderConfig): Record<string, unknown> {
+  return {
+    path: config.path,
+    command: config.command,
+    defaultArgs: config.defaultArgs,
+    env: maskEnv(config.env),
+    pluginDirs: config.pluginDirs,
+    defaultCapabilities: config.defaultCapabilities,
+    defaultApprovalMode: config.defaultApprovalMode,
+    defaultTags: config.defaultTags,
+    headless: config.headless,
+  };
+}
+
+export function runnerId(provider: string, cwd: string, label?: string): string {
+  const project = cwd.split("/").filter(Boolean).at(-1) || "workspace";
+  const cleanLabel = (label || project).replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
+  return `${hostname()}-${provider}-${cleanLabel}-${crypto.randomUUID().slice(0, 8)}`;
+}
+
+export function resolveCwd(value: string | undefined, fallback: string): string {
+  return resolve(value || fallback);
+}
+
+function readJson(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function positiveInteger(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+function stringArray(value: unknown): string[] | undefined {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
+}
+
+function stringRecord(value: unknown): Record<string, string> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const entries = Object.entries(value);
+  if (entries.some(([, item]) => typeof item !== "string")) return undefined;
+  return Object.fromEntries(entries) as Record<string, string>;
+}
+
+function recordValue(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function maskEnv(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = /token|secret|key|password/i.test(key) && !value.startsWith("$env:") ? "********" : value;
+  }
+  return result;
+}

package/scripts/orchestrator-spawn-smoke.ts

@@ -115,20 +115,13 @@ for (const provider of providers) {
   });
   console.log(`registered ${provider}: ${agent.id}`);
 
-  const managed = await waitFor(`waiting for ${provider} managed session`, async () => {
+  await waitFor(`waiting for ${provider} managed session`, async () => {
     const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
     return latest?.managedAgents?.find((entry) => entry.label === label || entry.tmuxSession.includes(label)) || null;
   });
 
-  await api("POST", `/orchestrators/${encodeURIComponent(orchestrator.id)}/actions`, {
+  await api("POST", `/agents/${encodeURIComponent(agent.id)}/actions`, {
     action: "shutdown",
-    agentId: managed.tmuxSession,
-  });
-
-  await waitFor(`waiting for ${provider} managed session shutdown`, async () => {
-    const latest = (await api<Orchestrator[]>("GET", "/orchestrators")).find((orch) => orch.id === orchestrator.id);
-    const stillManaged = latest?.managedAgents?.some((managed) => managed.label === label || managed.tmuxSession.includes(label));
-    return stillManaged ? null : true;
   });
   await waitFor(`waiting for ${provider} agent cleanup`, async () => {
     const current = await apiOptional<Agent>("GET", `/agents/${encodeURIComponent(agent.id)}`);

package/src/agent-spawn.ts

@@ -1,27 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, delimiter, dirname, join, resolve } from "node:path";
-
-export type CodexSpawnApprovalMode = "open" | "guarded" | "read-only";
-
-interface CodexSpawnInput {
-  cwd?: string;
-  approvalMode: CodexSpawnApprovalMode;
-  label?: string;
-  relayUrl: string;
-  token?: string;
-  dryRun?: boolean;
-}
-
-interface CodexSpawnResult {
-  provider: "codex";
-  pid?: number;
-  cwd: string;
-  approvalMode: CodexSpawnApprovalMode;
-  logPath: string;
-  command: string[];
-  dryRun?: boolean;
-}
+import { dirname, join, resolve } from "node:path";
 
 interface HostDirectoryEntry {
   name: string;
@@ -64,74 +43,3 @@ export function listHostDirectories(raw: string | undefined): HostDirectoryListi
     entries,
   };
 }
-
-export function codexSpawnCommand(): string[] {
-  const override = process.env.AGENT_RELAY_CODEX_RELAY_BIN;
-  if (override) return [override];
-
-  const repoLauncher = resolve(import.meta.dir, "../codex/bin/agent-relay-codex.ts");
-  if (existsSync(repoLauncher)) return ["bun", "run", repoLauncher, "start"];
-
-  const fromPath = findOnPath("codex-relay");
-  if (fromPath) return [fromPath];
-
-  return ["codex-relay"];
-}
-
-export function codexSpawnLogPath(cwd: string, now = Date.now()): string {
-  const project = basename(cwd).replace(/[^a-zA-Z0-9._-]+/g, "-") || "project";
-  return join(homedir(), ".agent-relay", "spawns", `codex-${project}-${now}.log`);
-}
-
-export function spawnCodexAgent(input: CodexSpawnInput): CodexSpawnResult {
-  const cwd = normalizeCodexSpawnCwd(input.cwd);
-  const command = [
-    ...codexSpawnCommand(),
-    "--headless",
-    "--relay-url",
-    input.relayUrl,
-  ];
-  const logPath = codexSpawnLogPath(cwd);
-  const env: Record<string, string | undefined> = {
-    ...process.env,
-    AGENT_RELAY_CODEX_HEADLESS: "1",
-    AGENT_RELAY_APPROVAL: input.approvalMode,
-    AGENT_RELAY_TAGS: mergeCsv(process.env.AGENT_RELAY_TAGS, ["headless", "dashboard-spawned"]),
-    AGENT_RELAY_LABEL: input.label || process.env.AGENT_RELAY_LABEL,
-    AGENT_RELAY_URL: input.relayUrl,
-    AGENT_RELAY_TOKEN: input.token || process.env.AGENT_RELAY_TOKEN,
-  };
-
-  if (input.dryRun) {
-    return { provider: "codex", cwd, approvalMode: input.approvalMode, logPath, command, dryRun: true };
-  }
-
-  mkdirSync(dirname(logPath), { recursive: true });
-  const log = Bun.file(logPath);
-  const child = Bun.spawn(command, {
-    cwd,
-    env,
-    stdin: "ignore",
-    stdout: log,
-    stderr: log,
-  });
-  child.unref();
-
-  return { provider: "codex", pid: child.pid, cwd, approvalMode: input.approvalMode, logPath, command };
-}
-
-function mergeCsv(raw: string | undefined, additions: string[]): string {
-  return [...new Set([
-    ...(raw || "").split(",").map((item) => item.trim()).filter(Boolean),
-    ...additions,
-  ])].join(",");
-}
-
-function findOnPath(command: string): string | null {
-  for (const dir of (process.env.PATH || "").split(delimiter)) {
-    if (!dir) continue;
-    const candidate = join(dir, command);
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}