npm - agent-relay-server - Versions diffs - 0.9.0 → 0.10.0 - Mend

agent-relay-server 0.9.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/README.md +12 -14
package/package.json +18 -1
package/public/index.html +979 -2575
package/public/manifest.webmanifest +6 -6
package/public/sw.js +16 -10
package/recipes/code-review.yaml +26 -0
package/recipes/debug.yaml +20 -0
package/recipes/feature.yaml +26 -0
package/recipes/refactor.yaml +20 -0
package/recipes/test.yaml +20 -0
package/runner/src/adapter.ts +69 -0
package/runner/src/config.ts +144 -0
package/scripts/orchestrator-spawn-smoke.ts +2 -9
package/src/agent-spawn.ts +2 -94
package/src/automations.ts +774 -0
package/src/bus-outbox.ts +75 -0
package/src/bus.ts +439 -0
package/src/cli.ts +251 -5
package/src/commands-db.ts +160 -0
package/src/config.ts +1 -1
package/src/connectors.ts +29 -9
package/src/daemon.ts +1 -0
package/src/db.ts +241 -34
package/src/events.ts +33 -0
package/src/index.ts +94 -5
package/src/recipe-db.ts +163 -0
package/src/recipe-loader.ts +100 -0
package/src/recipe-runner.ts +206 -0
package/src/recipe-validator.ts +85 -0
package/src/routes.ts +649 -155
package/src/security.ts +128 -2
package/src/sse.ts +42 -31
package/src/token-db.ts +96 -0
package/src/types.ts +1 -493
package/src/upgrade.ts +14 -28
package/public/dashboard/actions.js +0 -819
package/public/dashboard/api.js +0 -336
package/public/dashboard/app.js +0 -34
package/public/dashboard/charts.js +0 -128
package/public/dashboard/computed.js +0 -693
package/public/dashboard/constants.js +0 -28
package/public/dashboard/display.js +0 -345
package/public/dashboard/state.js +0 -129
package/public/dashboard/utils.js +0 -207

package/src/cli.ts CHANGED Viewed

@@ -1,6 +1,7 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import {
   createDaemonPlan,
@@ -34,6 +35,9 @@ Usage:
   agent-relay upgrade [--dry-run] [--version VERSION] [--providers auto|all|codex|claude|orchestrator] [--no-restart] [--yes]
   agent-relay setup upgrade [same options as upgrade]
   agent-relay daemon <install|uninstall|start|stop|restart|enable|disable|status|logs> [options]
+  agent-relay recipe <list|show|start|stop|status> [options]
+  agent-relay provider <wrap|unwrap> <claude|codex>
+  agent-relay token <create|list|revoke|verify> [options]
   agent-relay pair <target|create|status|accept|reject|hangup|send> [options]
   agent-relay message <target> <body> [options]
   agent-relay /pair <target|accept|reject|send|status> [...]
@@ -80,6 +84,17 @@ Upgrade options:
   --no-restart      Do not restart agent-relay.service
   --dry-run         Print detected state and planned commands
   --yes             Skip confirmation prompts
+Recipe examples:
+  agent-relay recipe list
+  agent-relay recipe start code-review --cwd /repo --orchestrator local
+  agent-relay recipe status
+  agent-relay recipe stop INSTANCE_ID
+Token examples:
+  agent-relay token create --role orchestrator --sub macmini --ttl 86400
+  agent-relay token list
+  agent-relay token revoke JTI
 `.trim();
 const DAEMON_ACTIONS = new Set<DaemonAction>([
@@ -117,6 +132,18 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
     await handleDaemonCommand(args.slice(1));
     return "handled";
   }
+  if (command === "recipe" || command === "recipes") {
+    await handleRecipeCommand(args.slice(1));
+    return "handled";
+  }
+  if (command === "provider" || command === "providers") {
+    await handleProviderCommand(args.slice(1));
+    return "handled";
+  }
+  if (command === "token" || command === "tokens") {
+    await handleTokenCommand(args.slice(1));
+    return "handled";
+  }
   if (command === "pair" || command === "/pair" || command === "/disconnect") {
     await handleSlashOrPairCommand(command, args.slice(1));
     return "handled";
@@ -142,7 +169,7 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
     return "handled";
   }
   if (command === "/reconnect") {
-    console.log("Reconnect is handled automatically by provider sidecars; use `agent-relay pair status` to inspect current pair state.");
+    console.log("Reconnect is handled automatically by provider runners; use `agent-relay pair status` to inspect current pair state.");
     return "handled";
   }
   throw new Error(`Unknown command "${command}". Run agent-relay --help.`);
@@ -211,6 +238,26 @@ function parseUpgradeProvider(value: string): UpgradeProvider {
   throw new Error(`Unknown upgrade provider "${value}". Expected auto, all, codex, claude, or orchestrator.`);
 }
+async function handleProviderCommand(args: string[]): Promise<void> {
+  const action = args[0];
+  const provider = args[1];
+  if ((action !== "wrap" && action !== "unwrap") || (provider !== "claude" && provider !== "codex")) {
+    throw new Error("Usage: agent-relay provider <wrap|unwrap> <claude|codex>");
+  }
+  const dir = join(homedir(), ".agent-relay", "bin");
+  const shim = join(dir, provider);
+  if (action === "wrap") {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(shim, `#!/usr/bin/env bash\nexec ${provider}-relay -- "$@"\n`, "utf8");
+    chmodSync(shim, 0o755);
+    console.log(`Wrapped ${provider}: ${shim}`);
+    console.log(`Ensure ${dir} is before the provider binary on PATH.`);
+    return;
+  }
+  if (existsSync(shim)) unlinkSync(shim);
+  console.log(`Unwrapped ${provider}: ${shim}`);
+}
 async function handleSlashOrPairCommand(command: string, args: string[]): Promise<void> {
   if (command === "/disconnect") {
     await handlePairCommand(["hangup", ...args]);
@@ -614,6 +661,134 @@ async function handleTagsCommand(args: string[]): Promise<void> {
   else console.log(`Tags: ${next.join(", ") || "(none)"}`);
 }
+async function handleRecipeCommand(args: string[]): Promise<void> {
+  const action = args[0] ?? "list";
+  const rest = args.slice(1);
+  if (action === "list") {
+    const json = rest.includes("--json");
+    const recipes = await apiRequest("GET", "/api/recipes");
+    if (json) console.log(JSON.stringify(recipes, null, 2));
+    else console.log(formatRecipes(recipes as any[]));
+    return;
+  }
+  if (action === "show") {
+    const name = rest.find((arg) => !arg.startsWith("--"));
+    const json = rest.includes("--json");
+    if (!name) throw new Error("Usage: agent-relay recipe show NAME [--json]");
+    const recipe = await apiRequest("GET", `/api/recipes/${encodeURIComponent(name)}`);
+    if (json) console.log(JSON.stringify(recipe, null, 2));
+    else console.log(formatRecipe(recipe as any));
+    return;
+  }
+  if (action === "start") {
+    const name = rest[0];
+    if (!name || name.startsWith("--")) throw new Error("Usage: agent-relay recipe start NAME [--cwd PATH] [--orchestrator ID] [--by NAME] [--json]");
+    let cwd: string | undefined;
+    let orchestratorId: string | undefined;
+    let startedBy: string | undefined;
+    let json = false;
+    for (let i = 1; i < rest.length; i++) {
+      const arg = rest[i];
+      if (arg === "--cwd" && i + 1 < rest.length) cwd = rest[++i];
+      else if ((arg === "--orchestrator" || arg === "--orchestrator-id") && i + 1 < rest.length) orchestratorId = rest[++i];
+      else if (arg === "--by" && i + 1 < rest.length) startedBy = rest[++i];
+      else if (arg === "--json") json = true;
+      else throw new Error(`Unknown recipe start option "${arg}"`);
+    }
+    const result = await apiRequest("POST", "/api/recipes/start", { name, cwd, orchestratorId, startedBy });
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else {
+      const payload = result as any;
+      console.log(`Recipe ${payload.instance.recipeName} started: ${payload.instance.id} (${payload.commands.length} command(s))`);
+    }
+    return;
+  }
+  if (action === "stop") {
+    const id = rest[0];
+    if (!id || id.startsWith("--")) throw new Error("Usage: agent-relay recipe stop INSTANCE_ID [--by NAME] [--json]");
+    let stoppedBy: string | undefined;
+    let json = false;
+    for (let i = 1; i < rest.length; i++) {
+      const arg = rest[i];
+      if (arg === "--by" && i + 1 < rest.length) stoppedBy = rest[++i];
+      else if (arg === "--json") json = true;
+      else throw new Error(`Unknown recipe stop option "${arg}"`);
+    }
+    const result = await apiRequest("POST", `/api/recipes/instances/${encodeURIComponent(id)}/stop`, { stoppedBy });
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else {
+      const payload = result as any;
+      console.log(`Recipe ${payload.instance.recipeName} stopped: ${payload.instance.id} (${payload.commands.length} command(s))`);
+    }
+    return;
+  }
+  if (action === "status" || action === "instances") {
+    const json = rest.includes("--json");
+    const instances = await apiRequest("GET", "/api/recipes/instances");
+    if (json) console.log(JSON.stringify(instances, null, 2));
+    else console.log(formatRecipeInstances(instances as any[]));
+    return;
+  }
+  throw new Error("Usage: agent-relay recipe <list|show|start|stop|status> [options]");
+}
+async function handleTokenCommand(args: string[]): Promise<void> {
+  const action = args[0] ?? "list";
+  const rest = args.slice(1);
+  if (action === "list") {
+    const json = rest.includes("--json");
+    const tokens = await apiRequest("GET", "/api/tokens");
+    if (json) console.log(JSON.stringify(tokens, null, 2));
+    else console.log(formatTokens(tokens as any[]));
+    return;
+  }
+  if (action === "create") {
+    let role: string | undefined;
+    let sub: string | undefined;
+    let ttlSeconds: number | undefined;
+    let json = false;
+    let scope: string[] | undefined;
+    for (let i = 0; i < rest.length; i++) {
+      const arg = rest[i];
+      if (arg === "--role" && i + 1 < rest.length) role = rest[++i];
+      else if (arg === "--sub" && i + 1 < rest.length) sub = rest[++i];
+      else if ((arg === "--scope" || arg === "--scopes") && i + 1 < rest.length) scope = splitTagArgs(rest[++i]!);
+      else if ((arg === "--ttl" || arg === "--ttl-seconds") && i + 1 < rest.length) ttlSeconds = parseInt(rest[++i]!, 10);
+      else if (arg === "--json") json = true;
+      else throw new Error(`Unknown token create option "${arg}"`);
+    }
+    if (!role) throw new Error("Usage: agent-relay token create --role ROLE [--sub SUBJECT] [--scope a,b] [--ttl SECONDS]");
+    const result = await apiRequest("POST", "/api/tokens", { role, sub, scope, ttlSeconds, createdBy: "cli" });
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else {
+      const payload = result as any;
+      console.log(payload.token);
+      console.error(`Issued ${payload.record.role} token ${payload.record.jti} for ${payload.record.sub}`);
+    }
+    return;
+  }
+  if (action === "revoke") {
+    const jti = rest.find((arg) => !arg.startsWith("--"));
+    if (!jti) throw new Error("Usage: agent-relay token revoke JTI");
+    await apiRequest("POST", `/api/tokens/${encodeURIComponent(jti)}/revoke`, {});
+    console.log(`Token revoked: ${jti}`);
+    return;
+  }
+  if (action === "verify") {
+    const token = rest.find((arg) => !arg.startsWith("--")) ?? process.env.AGENT_RELAY_TOKEN;
+    if (!token) throw new Error("Usage: agent-relay token verify TOKEN");
+    const payload = decodeJwtPayload(token);
+    if (!payload) throw new Error("not a component JWT");
+    let record: unknown = null;
+    if (typeof payload.jti === "string") {
+      record = await apiRequest("GET", `/api/tokens/${encodeURIComponent(payload.jti)}`).catch(() => null);
+    }
+    console.log(JSON.stringify({ payload, record }, null, 2));
+    return;
+  }
+  throw new Error("Usage: agent-relay token <create|list|revoke|verify> [options]");
+}
 async function apiRequest(method: string, path: string, body?: unknown): Promise<unknown> {
   const baseUrl = process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850";
   const headers: Record<string, string> = {};
@@ -687,13 +862,14 @@ function currentAgentContextId(): string | undefined {
   const explicitPath = process.env.AGENT_RELAY_CONTEXT_PATH;
   if (explicitPath) {
     const explicit = readAgentContext(explicitPath);
-    if (explicit?.agentId) return explicit.agentId;
+    if (explicit?.agentId && contextMatchesCurrentProcess(explicit)) return explicit.agentId;
   }
   const candidates = collectAgentContextFiles();
   const matches = candidates
     .map((path) => readAgentContext(path))
-    .filter((context): context is { agentId: string; updatedAtMs: number; matchEnv: Array<{ name: string; value: string }> } => Boolean(context))
+    .filter((context): context is AgentContextState => Boolean(context))
+    .filter((context) => contextMatchesCurrentProcess(context))
     .filter((context) => context.matchEnv.some((match) => process.env[match.name] === match.value))
     .sort((a, b) => b.updatedAtMs - a.updatedAtMs);
@@ -701,11 +877,23 @@ function currentAgentContextId(): string | undefined {
   return uniqueAgentIds.length === 1 ? uniqueAgentIds[0] : undefined;
 }
-function readAgentContext(path: string): { agentId: string; updatedAtMs: number; matchEnv: Array<{ name: string; value: string }> } | null {
+interface AgentContextState {
+  agentId: string;
+  cwd?: string;
+  updatedAtMs: number;
+  matchEnv: Array<{ name: string; value: string }>;
+}
+function contextMatchesCurrentProcess(context: AgentContextState): boolean {
+  return !context.cwd || context.cwd === process.cwd();
+}
+function readAgentContext(path: string): AgentContextState | null {
   if (!existsSync(path)) return null;
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8")) as {
       agentId?: unknown;
+      cwd?: unknown;
       updatedAt?: unknown;
       matchEnv?: unknown;
     };
@@ -723,6 +911,7 @@ function readAgentContext(path: string): { agentId: string; updatedAtMs: number;
     const updatedAt = typeof parsed.updatedAt === "string" ? Date.parse(parsed.updatedAt) : Number.NaN;
     return {
       agentId: parsed.agentId,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : undefined,
       matchEnv,
       updatedAtMs: Number.isFinite(updatedAt) ? updatedAt : stat.mtimeMs,
     };
@@ -834,6 +1023,63 @@ function formatStatus(payload: any): string {
   ].join("\n");
 }
+function formatRecipes(recipes: any[]): string {
+  if (!recipes.length) return "No recipes.";
+  return recipes
+    .map((entry) => {
+      const recipe = entry.recipe ?? {};
+      const agents = Array.isArray(recipe.agents)
+        ? recipe.agents.map((agent: any) => `${agent.count ?? 1}x ${agent.provider}:${agent.role}`).join(", ")
+        : "no agents";
+      return `${entry.name}  ${entry.source}  ${agents}  ${recipe.description ?? ""}`.trim();
+    })
+    .join("\n");
+}
+function formatRecipe(entry: any): string {
+  const recipe = entry.recipe ?? {};
+  const agents = Array.isArray(recipe.agents)
+    ? recipe.agents.map((agent: any) => `  - ${agent.count ?? 1}x ${agent.provider}:${agent.role}`).join("\n")
+    : "  (none)";
+  return [
+    `${entry.name} (${entry.source})`,
+    recipe.description,
+    "Agents:",
+    agents,
+  ].filter(Boolean).join("\n");
+}
+function formatRecipeInstances(instances: any[]): string {
+  if (!instances.length) return "No recipe instances.";
+  return instances
+    .map((instance) => {
+      const agents = Array.isArray(instance.agents) ? instance.agents.length : 0;
+      return `${instance.id}  ${instance.status}  ${instance.recipeName}  agents=${agents}  cwd=${instance.cwd}`;
+    })
+    .join("\n");
+}
+function formatTokens(tokens: any[]): string {
+  if (!tokens.length) return "No component tokens.";
+  return tokens
+    .map((token) => {
+      const state = token.revokedAt ? "revoked" : token.expiresAt && token.expiresAt <= Math.floor(Date.now() / 1000) ? "expired" : "active";
+      return `${token.jti}  ${state}  ${token.role}  ${token.sub}  ${(token.scope ?? []).join(",")}`;
+    })
+    .join("\n");
+}
+function decodeJwtPayload(token: string): Record<string, unknown> | null {
+  const payload = token.split(".")[1];
+  if (!payload) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
 async function confirm(message: string): Promise<boolean> {
   if (!input.isTTY) return false;
   const rl = createInterface({ input, output });

package/src/commands-db.ts ADDED Viewed

@@ -0,0 +1,160 @@
+import { randomUUID } from "node:crypto";
+import { getDb } from "./db";
+import type { Command, CommandStatus, CreateCommandInput, UpdateCommandInput } from "./types";
+interface CommandRow {
+  id: string;
+  type: string;
+  source: string;
+  target: string;
+  params: string;
+  status: CommandStatus;
+  result: string | null;
+  error: string | null;
+  correlation_id: string | null;
+  created_at: number;
+  updated_at: number;
+  expires_at: number | null;
+}
+interface CommandFilters {
+  target?: string;
+  status?: CommandStatus;
+  type?: string;
+  since?: number;
+  limit?: number;
+}
+const ACTIVE_STATUSES: CommandStatus[] = ["pending", "accepted", "running"];
+export function createCommand(input: CreateCommandInput): Command {
+  const now = Date.now();
+  const command: Command = {
+    id: randomUUID(),
+    type: input.type,
+    source: input.source,
+    target: input.target,
+    params: input.params ?? {},
+    status: "pending",
+    correlationId: input.correlationId,
+    createdAt: now,
+    updatedAt: now,
+    expiresAt: input.ttlMs ? now + input.ttlMs : defaultExpiresAt(input.type, now),
+  };
+  getDb().prepare(`
+    INSERT INTO commands (id, type, source, target, params, status, correlation_id, created_at, updated_at, expires_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    command.id,
+    command.type,
+    command.source,
+    command.target,
+    JSON.stringify(command.params),
+    command.status,
+    command.correlationId ?? null,
+    command.createdAt,
+    command.updatedAt,
+    command.expiresAt ?? null,
+  );
+  return command;
+}
+export function getCommand(id: string): Command | null {
+  const row = getDb().prepare("SELECT * FROM commands WHERE id = ?").get(id) as CommandRow | undefined;
+  return row ? rowToCommand(row) : null;
+}
+export function listCommands(filters: CommandFilters = {}): Command[] {
+  const clauses: string[] = [];
+  const params: unknown[] = [];
+  if (filters.target) {
+    clauses.push("target = ?");
+    params.push(filters.target);
+  }
+  if (filters.status) {
+    clauses.push("status = ?");
+    params.push(filters.status);
+  }
+  if (filters.type) {
+    clauses.push("type = ?");
+    params.push(filters.type);
+  }
+  if (filters.since !== undefined) {
+    clauses.push("created_at >= ?");
+    params.push(filters.since);
+  }
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const limit = Math.min(Math.max(filters.limit ?? 100, 1), 500);
+  const bindings = [...params, limit] as any[];
+  const rows = getDb()
+    .prepare(`SELECT * FROM commands ${where} ORDER BY created_at DESC LIMIT ?`)
+    .all(...bindings) as CommandRow[];
+  return rows.map(rowToCommand);
+}
+export function updateCommand(id: string, input: UpdateCommandInput): Command | null {
+  const existing = getCommand(id);
+  if (!existing) return null;
+  const nextStatus = input.status ?? existing.status;
+  const now = Date.now();
+  getDb().prepare(`
+    UPDATE commands
+    SET status = ?, result = ?, error = ?, updated_at = ?
+    WHERE id = ?
+  `).run(
+    nextStatus,
+    input.result !== undefined ? JSON.stringify(input.result) : existing.result ? JSON.stringify(existing.result) : null,
+    input.error ?? existing.error ?? null,
+    now,
+    id,
+  );
+  return getCommand(id);
+}
+export function deleteCommand(id: string): boolean {
+  const existing = getCommand(id);
+  if (!existing) return false;
+  if (!["pending", "accepted"].includes(existing.status)) return false;
+  updateCommand(id, { status: "canceled", error: "canceled" });
+  return true;
+}
+export function expireCommands(now: number = Date.now()): Command[] {
+  const rows = getDb()
+    .prepare(`SELECT * FROM commands WHERE expires_at IS NOT NULL AND expires_at <= ? AND status IN (${ACTIVE_STATUSES.map(() => "?").join(",")})`)
+    .all(now, ...ACTIVE_STATUSES) as CommandRow[];
+  for (const row of rows) updateCommand(row.id, { status: "timed_out", error: "command timed out" });
+  return rows.map((row) => getCommand(row.id)).filter((command): command is Command => Boolean(command));
+}
+function defaultExpiresAt(type: string, now: number): number | undefined {
+  if (type === "agent.spawn") return now + 60_000;
+  if (type === "agent.shutdown" || type === "agent.restart" || type === "agent.kill") return now + 30_000;
+  return undefined;
+}
+function rowToCommand(row: CommandRow): Command {
+  return {
+    id: row.id,
+    type: row.type,
+    source: row.source,
+    target: row.target,
+    params: parseObject(row.params),
+    status: row.status,
+    result: row.result ? parseObject(row.result) : undefined,
+    error: row.error ?? undefined,
+    correlationId: row.correlation_id ?? undefined,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    expiresAt: row.expires_at ?? undefined,
+  };
+}
+function parseObject(raw: string): Record<string, unknown> {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}

package/src/config.ts CHANGED Viewed

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf8"));
 export const VERSION: string = pkg.version;
-export const ORCHESTRATOR_PROTOCOL_VERSION = 2;
+export const ORCHESTRATOR_PROTOCOL_VERSION = 3;
 export const DAY_MS = 86_400_000;
 function envPositiveInt(name: string, fallback: number): number {

package/src/connectors.ts CHANGED Viewed

@@ -7,6 +7,7 @@ import { ValidationError } from "./db";
 const CONNECTOR_SCHEMA = "agent-relay.connector.v1";
 const VALID_KINDS = new Set(["channel", "event", "provider", "orchestrator"]);
 const VALID_ACTIONS = new Set(["install", "uninstall", "enable", "disable", "start", "stop", "restart", "status", "doctor"]);
+const DEFAULT_ACTION_TIMEOUT_MS = 30_000;
 function connectorRegistryDir(): string {
   const configured = process.env.AGENT_RELAY_CONNECTORS_DIR;
@@ -173,31 +174,50 @@ export function writeConnectorConfig(id: string, config: Record<string, unknown>
   return config;
 }
-export function runConnectorAction(id: string, action: ConnectorAction): ConnectorActionResult {
+function connectorActionTimeoutMs(): number {
+  const raw = Number(process.env.AGENT_RELAY_CONNECTOR_ACTION_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_ACTION_TIMEOUT_MS;
+}
+export async function runConnectorAction(id: string, action: ConnectorAction): Promise<ConnectorActionResult> {
   if (!VALID_ACTIONS.has(action)) throw new ValidationError("unsupported connector action");
   const connector = getConnector(id);
   if (!connector) throw new ValidationError(`connector ${id} not found`);
   const command = connector.manifest.commands[action];
   if (!command?.length) throw new ValidationError(`connector ${id} does not support ${action}`);
-  const proc = Bun.spawnSync({
+  const proc = Bun.spawn({
     cmd: command,
     stdout: "pipe",
     stderr: "pipe",
     env: { ...process.env, AGENT_RELAY_CONNECTOR_ID: id, AGENT_RELAY_CONNECTORS_DIR: connectorRegistryDir() },
   });
-  const stdout = new TextDecoder().decode(proc.stdout).trim();
-  const stderr = new TextDecoder().decode(proc.stderr).trim();
-  const parsed = parseJsonMaybe(stdout);
-  const ok = proc.success;
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    proc.kill();
+  }, connectorActionTimeoutMs());
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  clearTimeout(timeout);
+  const trimmedStdout = stdout.trim();
+  const trimmedStderr = stderr.trim();
+  const parsed = parseJsonMaybe(trimmedStdout);
+  const ok = exitCode === 0 && !timedOut;
   const result: ConnectorActionResult = {
     connectorId: id,
     action,
     command,
     ok,
-    exitCode: proc.exitCode,
-    stdout,
-    stderr,
+    exitCode,
+    stdout: trimmedStdout,
+    stderr: timedOut ? [trimmedStderr, `connector action timed out after ${connectorActionTimeoutMs()}ms`].filter(Boolean).join("\n") : trimmedStderr,
     parsed,
   };
   if ((action === "status" || action === "doctor") && ok) {

package/src/daemon.ts CHANGED Viewed

@@ -372,6 +372,7 @@ function systemdServicePath(): string {
     dirname(process.execPath),
     join(homedir(), ".bun", "bin"),
     join(homedir(), ".npm-global", "bin"),
+    join(homedir(), ".local", "bin"),
     "/usr/local/sbin",
     "/usr/local/bin",
     "/usr/sbin",