@rk0429/agentic-relay 0.1.0

package/dist/relay.mjs

@@ -0,0 +1,2292 @@
+#!/usr/bin/env node
+
+// src/bin/relay.ts
+import { defineCommand as defineCommand10, runMain } from "citty";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/infrastructure/process-manager.ts
+import { execa } from "execa";
+
+// src/infrastructure/logger.ts
+import { createConsola } from "consola";
+var LOG_LEVEL_MAP = {
+  silent: -1,
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  debug: 4,
+  trace: 5,
+  verbose: 5
+};
+function resolveLogLevel() {
+  const envLevel = process.env["RELAY_LOG_LEVEL"]?.toLowerCase();
+  if (envLevel && envLevel in LOG_LEVEL_MAP) {
+    return LOG_LEVEL_MAP[envLevel];
+  }
+  return 3;
+}
+var logger = createConsola({
+  level: resolveLogLevel(),
+  defaults: {
+    tag: "relay"
+  }
+});
+
+// src/infrastructure/process-manager.ts
+var ProcessManager = class {
+  activeProcesses = /* @__PURE__ */ new Set();
+  constructor() {
+    this.setupSignalHandlers();
+  }
+  async spawnInteractive(command, args, options) {
+    logger.debug(`Spawning interactive: ${command} ${args.join(" ")}`);
+    const execaOptions = {
+      stdio: "inherit",
+      cwd: options?.cwd,
+      env: options?.env,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      await proc;
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  async execute(command, args, options) {
+    logger.debug(`Executing: ${command} ${args.join(" ")}`);
+    const execaOptions = {
+      stdio: "pipe",
+      cwd: options?.cwd,
+      env: options?.env,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      const result = await proc;
+      return {
+        exitCode: result.exitCode ?? 1,
+        stdout: result.stdout?.toString() ?? "",
+        stderr: result.stderr?.toString() ?? ""
+      };
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  async executeWithInput(command, args, stdinData, options) {
+    logger.debug(`Executing with stdin: ${command} ${args.join(" ")}`);
+    const execaOptions = {
+      stdio: "pipe",
+      input: stdinData,
+      cwd: options?.cwd,
+      env: options?.env,
+      timeout: options?.timeout,
+      reject: false
+    };
+    const proc = execa(command, args, execaOptions);
+    this.activeProcesses.add(proc);
+    try {
+      const result = await proc;
+      return {
+        exitCode: result.exitCode ?? 1,
+        stdout: result.stdout?.toString() ?? "",
+        stderr: result.stderr?.toString() ?? ""
+      };
+    } finally {
+      this.activeProcesses.delete(proc);
+    }
+  }
+  setupSignalHandlers() {
+    const handleSignal = (signal) => {
+      logger.debug(`Received ${signal}, forwarding to child processes`);
+      for (const proc of this.activeProcesses) {
+        proc.kill(signal);
+      }
+    };
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  }
+};
+
+// src/adapters/adapter-registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.id, adapter);
+  }
+  get(id) {
+    const adapter = this.adapters.get(id);
+    if (!adapter) {
+      throw new Error(
+        `Backend "${id}" is not registered. Available: ${[...this.adapters.keys()].join(", ")}`
+      );
+    }
+    return adapter;
+  }
+  has(id) {
+    return this.adapters.has(id);
+  }
+  list() {
+    return [...this.adapters.values()];
+  }
+};
+
+// src/adapters/base-adapter.ts
+var BaseAdapter = class {
+  constructor(processManager2) {
+    this.processManager = processManager2;
+  }
+  async isInstalled() {
+    try {
+      const result = await this.processManager.execute("which", [this.command]);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  async getVersion() {
+    const result = await this.processManager.execute(this.command, [
+      "--version"
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Failed to get version for ${this.id}: ${result.stderr}`
+      );
+    }
+    return result.stdout.trim();
+  }
+  async getMCPConfig() {
+    logger.warn(`getMCPConfig not implemented for ${this.id}`);
+    return [];
+  }
+  async setMCPConfig(_servers) {
+    logger.warn(`setMCPConfig not implemented for ${this.id}`);
+  }
+};
+
+// src/adapters/flag-mapper.ts
+var FLAG_MAP = {
+  prompt: {
+    claude: { flag: "-p" },
+    codex: null,
+    // Codex uses `exec` subcommand, handled by adapter
+    gemini: { flag: "-p" }
+  },
+  continue: {
+    claude: { flag: "-c" },
+    codex: null,
+    // Codex uses `resume --last`, handled by adapter
+    gemini: null
+    // Gemini uses `--resume` (no arg), handled by adapter
+  },
+  resume: {
+    claude: { flag: "-r" },
+    codex: null,
+    // Codex uses `resume SESSION_ID`, handled by adapter
+    gemini: null
+    // Gemini uses `--resume UUID`, handled by adapter
+  },
+  agent: {
+    claude: { flag: "--agent" },
+    codex: null,
+    // Not supported
+    gemini: null
+    // Not supported
+  },
+  model: {
+    claude: { flag: "--model" },
+    codex: { flag: "--model" },
+    gemini: { flag: "--model" }
+  },
+  maxTurns: {
+    claude: { flag: "--max-turns" },
+    codex: null,
+    gemini: null
+  },
+  outputFormat: {
+    claude: { flag: "--output-format" },
+    codex: null,
+    // Codex uses `--json` (boolean), handled by adapter
+    gemini: null
+    // Gemini uses `--output-format`, handled by adapter
+  },
+  verbose: {
+    claude: { flag: "--verbose" },
+    codex: null,
+    gemini: { flag: "--verbose" }
+  }
+};
+function mapCommonToNative(backendId, flags) {
+  const args = [];
+  for (const [key, mappings] of Object.entries(FLAG_MAP)) {
+    const value = flags[key];
+    if (value === void 0 || value === false) continue;
+    const mapping = mappings[backendId];
+    if (!mapping) continue;
+    if (mapping.transform) {
+      const transformed = mapping.transform(value);
+      if (transformed !== void 0) {
+        args.push(mapping.flag, transformed);
+      }
+    } else if (typeof value === "boolean") {
+      args.push(mapping.flag);
+    } else {
+      args.push(mapping.flag, String(value));
+    }
+  }
+  return args;
+}
+
+// src/adapters/claude-adapter.ts
+var ClaudeAdapter = class extends BaseAdapter {
+  id = "claude";
+  command = "claude";
+  mapFlags(flags) {
+    return {
+      args: mapCommonToNative("claude", flags)
+    };
+  }
+  async startInteractive(flags) {
+    const { args } = this.mapFlags(flags);
+    await this.processManager.spawnInteractive(this.command, args);
+  }
+  async execute(flags) {
+    if (!flags.prompt) {
+      throw new Error("execute requires a prompt (-p flag)");
+    }
+    const { args } = this.mapFlags(flags);
+    return this.processManager.execute(this.command, args);
+  }
+  async resumeSession(sessionId, _flags) {
+    await this.processManager.spawnInteractive(this.command, [
+      "-r",
+      sessionId
+    ]);
+  }
+  async listNativeSessions() {
+    logger.debug(
+      "listNativeSessions: claude --resume is interactive, returning empty array"
+    );
+    return [];
+  }
+  async auth(action) {
+    await this.processManager.spawnInteractive(this.command, ["auth", action]);
+  }
+  async update() {
+    logger.info("Updating Claude CLI...");
+    const result = await this.processManager.execute(this.command, ["update"]);
+    if (result.exitCode !== 0) {
+      logger.error(`Claude update failed: ${result.stderr}`);
+    } else {
+      logger.success(`Claude CLI updated: ${result.stdout.trim()}`);
+    }
+  }
+};
+
+// src/adapters/codex-adapter.ts
+var CodexAdapter = class extends BaseAdapter {
+  id = "codex";
+  command = "codex";
+  mapFlags(flags) {
+    const args = mapCommonToNative("codex", flags);
+    if (flags.outputFormat === "json") {
+      args.push("--json");
+    }
+    return { args };
+  }
+  async startInteractive(flags) {
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    if (flags.continue) {
+      args.push("resume", "--last");
+    }
+    await this.processManager.spawnInteractive(this.command, args);
+  }
+  async execute(flags) {
+    if (!flags.prompt) {
+      throw new Error("execute requires a prompt (-p flag)");
+    }
+    if (flags.agent) {
+      logger.warn(
+        `Codex CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
+      );
+    }
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    if (flags.outputFormat === "json") {
+      args.push("--json");
+    }
+    args.push("exec", flags.prompt);
+    return this.processManager.execute(this.command, args);
+  }
+  async resumeSession(sessionId, flags) {
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    args.push("resume", sessionId);
+    await this.processManager.spawnInteractive(this.command, args);
+  }
+  async listNativeSessions() {
+    logger.debug(
+      "listNativeSessions: Codex CLI does not provide a session list command"
+    );
+    return [];
+  }
+  async auth(action) {
+    if (action === "status") {
+      await this.processManager.spawnInteractive(this.command, [
+        "login",
+        "status"
+      ]);
+    } else {
+      await this.processManager.spawnInteractive(this.command, [action]);
+    }
+  }
+  async update() {
+    logger.info("Updating Codex CLI...");
+    const result = await this.processManager.execute("npm", [
+      "update",
+      "-g",
+      "@openai/codex"
+    ]);
+    if (result.exitCode !== 0) {
+      logger.error(`Codex update failed: ${result.stderr}`);
+    } else {
+      logger.success(`Codex CLI updated: ${result.stdout.trim()}`);
+    }
+  }
+};
+
+// src/adapters/gemini-adapter.ts
+var GeminiAdapter = class extends BaseAdapter {
+  id = "gemini";
+  command = "gemini";
+  mapFlags(flags) {
+    const args = mapCommonToNative("gemini", flags);
+    if (flags.outputFormat) {
+      args.push("--output-format", flags.outputFormat);
+    }
+    return { args };
+  }
+  async startInteractive(flags) {
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    if (flags.verbose) {
+      args.push("--verbose");
+    }
+    if (flags.continue) {
+      args.push("--resume");
+    }
+    await this.processManager.spawnInteractive(this.command, args);
+  }
+  async execute(flags) {
+    if (!flags.prompt) {
+      throw new Error("execute requires a prompt (-p flag)");
+    }
+    if (flags.agent) {
+      logger.warn(
+        `Gemini CLI does not support --agent flag. Ignoring agent "${flags.agent}".`
+      );
+    }
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    if (flags.outputFormat) {
+      args.push("--output-format", flags.outputFormat);
+    }
+    if (flags.verbose) {
+      args.push("--verbose");
+    }
+    args.push("-p", flags.prompt);
+    return this.processManager.execute(this.command, args);
+  }
+  async resumeSession(sessionId, flags) {
+    const args = [];
+    if (flags.model) {
+      args.push("--model", flags.model);
+    }
+    if (flags.verbose) {
+      args.push("--verbose");
+    }
+    args.push("--resume", sessionId);
+    await this.processManager.spawnInteractive(this.command, args);
+  }
+  async listNativeSessions() {
+    try {
+      const result = await this.processManager.execute(this.command, [
+        "--list-sessions"
+      ]);
+      if (result.exitCode !== 0) {
+        logger.debug(
+          `listNativeSessions failed for gemini: ${result.stderr}`
+        );
+        return [];
+      }
+      try {
+        const parsed = JSON.parse(result.stdout);
+        if (!Array.isArray(parsed)) return [];
+        return parsed.map(
+          (entry) => ({
+            nativeId: entry.id ?? "",
+            startedAt: entry.startedAt ? new Date(entry.startedAt) : /* @__PURE__ */ new Date(),
+            lastMessage: entry.lastMessage
+          })
+        );
+      } catch {
+        logger.debug(
+          "listNativeSessions: failed to parse gemini session list output"
+        );
+        return [];
+      }
+    } catch {
+      return [];
+    }
+  }
+  async auth(_action) {
+    logger.info(
+      "Gemini CLI does not have explicit auth commands. Launching gemini for initial authentication flow..."
+    );
+    await this.processManager.spawnInteractive(this.command, []);
+  }
+  async update() {
+    logger.info("Updating Gemini CLI...");
+    const result = await this.processManager.execute("npm", [
+      "update",
+      "-g",
+      "@google/gemini-cli"
+    ]);
+    if (result.exitCode !== 0) {
+      logger.error(`Gemini update failed: ${result.stderr}`);
+    } else {
+      logger.success(`Gemini CLI updated: ${result.stdout.trim()}`);
+    }
+  }
+};
+
+// src/core/session-manager.ts
+import { readFile, writeFile, readdir, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { nanoid } from "nanoid";
+function getRelayHome() {
+  return process.env["RELAY_HOME"] ?? join(homedir(), ".relay");
+}
+function getSessionsDir(relayHome2) {
+  return join(relayHome2, "sessions");
+}
+function toSessionData(session) {
+  return {
+    ...session,
+    createdAt: session.createdAt.toISOString(),
+    updatedAt: session.updatedAt.toISOString()
+  };
+}
+function fromSessionData(data) {
+  return {
+    ...data,
+    createdAt: new Date(data.createdAt),
+    updatedAt: new Date(data.updatedAt)
+  };
+}
+var SessionManager = class {
+  sessionsDir;
+  constructor(sessionsDir) {
+    this.sessionsDir = sessionsDir ?? getSessionsDir(getRelayHome());
+  }
+  /** Ensure the sessions directory exists. */
+  async ensureDir() {
+    await mkdir(this.sessionsDir, { recursive: true });
+  }
+  sessionPath(relaySessionId) {
+    return join(this.sessionsDir, `${relaySessionId}.json`);
+  }
+  /** Create a new relay session. */
+  async create(params) {
+    await this.ensureDir();
+    const now = /* @__PURE__ */ new Date();
+    const session = {
+      relaySessionId: `relay-${nanoid()}`,
+      nativeSessionId: params.nativeSessionId ?? null,
+      backendId: params.backendId,
+      parentSessionId: params.parentSessionId ?? null,
+      depth: params.depth ?? 0,
+      createdAt: now,
+      updatedAt: now,
+      status: "active"
+    };
+    await writeFile(
+      this.sessionPath(session.relaySessionId),
+      JSON.stringify(toSessionData(session), null, 2),
+      "utf-8"
+    );
+    return session;
+  }
+  /** Update an existing session. */
+  async update(relaySessionId, updates) {
+    const session = await this.get(relaySessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${relaySessionId}`);
+    }
+    const updated = {
+      ...session,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await writeFile(
+      this.sessionPath(relaySessionId),
+      JSON.stringify(toSessionData(updated), null, 2),
+      "utf-8"
+    );
+  }
+  /** Get a session by relay session ID. */
+  async get(relaySessionId) {
+    try {
+      const raw = await readFile(this.sessionPath(relaySessionId), "utf-8");
+      return fromSessionData(JSON.parse(raw));
+    } catch {
+      return null;
+    }
+  }
+  /** Get the most recent session for a given backend. */
+  async getLatest(backendId) {
+    const sessions = await this.list({ backendId, limit: 1 });
+    return sessions[0] ?? null;
+  }
+  /** List sessions, optionally filtered by backend and limited. */
+  async list(filter) {
+    await this.ensureDir();
+    let files;
+    try {
+      files = await readdir(this.sessionsDir);
+    } catch {
+      return [];
+    }
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    const sessions = [];
+    for (const file of jsonFiles) {
+      try {
+        const raw = await readFile(join(this.sessionsDir, file), "utf-8");
+        const session = fromSessionData(JSON.parse(raw));
+        if (filter?.backendId && session.backendId !== filter.backendId) {
+          continue;
+        }
+        sessions.push(session);
+      } catch {
+      }
+    }
+    sessions.sort(
+      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+    );
+    if (filter?.limit && filter.limit > 0) {
+      return sessions.slice(0, filter.limit);
+    }
+    return sessions;
+  }
+};
+
+// src/core/config-manager.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/schemas/config.schema.ts
+import { z } from "zod";
+var backendIdSchema = z.enum(["claude", "codex", "gemini"]);
+var mcpServerConfigSchema = z.object({
+  name: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional()
+});
+var hookEventSchema = z.enum([
+  "pre-prompt",
+  "post-response",
+  "on-error",
+  "on-context-threshold",
+  "pre-spawn",
+  "post-spawn"
+]);
+var hookDefinitionSchema = z.object({
+  event: hookEventSchema,
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  timeout: z.number().positive().optional(),
+  enabled: z.boolean().optional(),
+  onError: z.enum(["ignore", "warn", "abort"]).optional()
+});
+var hooksConfigSchema = z.object({
+  definitions: z.array(hookDefinitionSchema)
+});
+var relayConfigSchema = z.object({
+  defaultBackend: backendIdSchema.optional(),
+  mcpServers: z.record(mcpServerConfigSchema).optional(),
+  backends: z.object({
+    claude: z.record(z.unknown()).optional(),
+    codex: z.record(z.unknown()).optional(),
+    gemini: z.record(z.unknown()).optional()
+  }).optional(),
+  hooks: hooksConfigSchema.optional(),
+  contextMonitor: z.object({
+    enabled: z.boolean(),
+    thresholdPercent: z.number().min(0).max(100),
+    notifyMethod: z.enum(["stderr", "hook"])
+  }).optional(),
+  mcpServerMode: z.object({
+    maxDepth: z.number().int().positive(),
+    maxCallsPerSession: z.number().int().positive(),
+    timeoutSec: z.number().positive()
+  }).optional(),
+  telemetry: z.object({
+    enabled: z.boolean()
+  }).optional()
+});
+
+// src/core/config-manager.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function getByPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!isPlainObject(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setByPath(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isPlainObject(current[part])) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  current[lastPart] = value;
+}
+var ConfigManager = class {
+  constructor(globalDir, projectDir) {
+    this.globalDir = globalDir;
+    this.projectDir = projectDir;
+  }
+  /**
+   * Returns the merged config from all scopes (global < project < local).
+   */
+  async getConfig() {
+    const globalCfg = await this.readConfigFile(this.getFilePath("global"));
+    const projectCfg = this.projectDir ? await this.readConfigFile(this.getFilePath("project")) : {};
+    const localCfg = this.projectDir ? await this.readConfigFile(this.getFilePath("local")) : {};
+    const merged = deepMerge(
+      deepMerge(globalCfg, projectCfg),
+      localCfg
+    );
+    return this.validate(merged);
+  }
+  /**
+   * Returns config for a specific scope without merging.
+   */
+  async getConfigByScope(scope) {
+    const scopeFile = this.mapConfigScope(scope);
+    return this.readConfigFile(this.getFilePath(scopeFile));
+  }
+  /**
+   * Gets a value from the merged config using dot-path notation.
+   */
+  async get(key) {
+    const config = await this.getConfig();
+    return getByPath(config, key);
+  }
+  /**
+   * Sets a value in the specified scope's config file.
+   */
+  async set(scope, key, value) {
+    const scopeFile = this.mapConfigScope(scope);
+    const filePath = this.getFilePath(scopeFile);
+    if (scopeFile !== "global" && !this.projectDir) {
+      throw new Error(
+        `Cannot write to "${scope}" scope: no project directory configured`
+      );
+    }
+    const existing = await this.readConfigFile(filePath);
+    setByPath(existing, key, value);
+    const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(filePath, JSON.stringify(existing, null, 2), "utf-8");
+  }
+  /**
+   * Syncs MCP server config to all registered backend adapters.
+   */
+  async syncMCPConfig(registry2) {
+    const config = await this.getConfig();
+    const mcpServers = config.mcpServers ?? {};
+    const servers = Object.values(mcpServers);
+    const adapters = registry2.list();
+    for (const adapter of adapters) {
+      try {
+        await adapter.setMCPConfig(servers);
+        logger.success(`Synced MCP config to ${adapter.id}`);
+      } catch (error) {
+        logger.error(
+          `Failed to sync MCP config to ${adapter.id}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  // --- Private helpers ---
+  getFilePath(scope) {
+    switch (scope) {
+      case "global":
+        return join2(this.globalDir, "config.json");
+      case "project":
+        return join2(this.projectDir ?? "", "config.json");
+      case "local":
+        return join2(this.projectDir ?? "", "config.local.json");
+    }
+  }
+  mapConfigScope(scope) {
+    switch (scope) {
+      case "global":
+        return "global";
+      case "project":
+        return "project";
+      case "session":
+        return "local";
+      default:
+        return "global";
+    }
+  }
+  async readConfigFile(filePath) {
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!isPlainObject(parsed)) return {};
+      return parsed;
+    } catch {
+      return {};
+    }
+  }
+  validate(raw) {
+    const result = relayConfigSchema.safeParse(raw);
+    if (result.success) {
+      return result.data;
+    }
+    logger.warn(
+      `Config validation warnings: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`
+    );
+    const partial = {};
+    for (const key of Object.keys(raw)) {
+      const singleField = { [key]: raw[key] };
+      const fieldResult = relayConfigSchema.partial().safeParse(singleField);
+      if (fieldResult.success) {
+        Object.assign(partial, fieldResult.data);
+      }
+    }
+    return partial;
+  }
+};
+
+// src/core/auth-manager.ts
+var AuthManager = class {
+  constructor(registry2) {
+    this.registry = registry2;
+  }
+  /**
+   * Delegates auth action to the specified backend adapter.
+   */
+  async auth(backendId, action) {
+    const adapter = this.registry.get(backendId);
+    await adapter.auth(action);
+  }
+  /**
+   * Shows auth status for all registered backends.
+   */
+  async statusAll() {
+    const adapters = this.registry.list();
+    if (adapters.length === 0) {
+      logger.info("No backends registered");
+      return;
+    }
+    for (const adapter of adapters) {
+      try {
+        logger.info(`--- ${adapter.id} ---`);
+        await adapter.auth("status");
+      } catch (error) {
+        logger.error(
+          `Failed to get auth status for ${adapter.id}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+};
+
+// src/core/event-bus.ts
+var EventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  /** Register an event listener */
+  on(event, handler) {
+    const existing = this.handlers.get(event) ?? [];
+    existing.push(handler);
+    this.handlers.set(event, existing);
+  }
+  /** Remove an event listener */
+  off(event, handler) {
+    const existing = this.handlers.get(event);
+    if (!existing) return;
+    const index = existing.indexOf(handler);
+    if (index !== -1) {
+      existing.splice(index, 1);
+    }
+    if (existing.length === 0) {
+      this.handlers.delete(event);
+    }
+  }
+  /** Emit an event, executing all handlers sequentially */
+  async emit(event, data) {
+    const handlers = this.handlers.get(event);
+    if (!handlers) return;
+    for (const handler of handlers) {
+      await handler(data);
+    }
+  }
+  /** Get the number of handlers for a given event */
+  listenerCount(event) {
+    return this.handlers.get(event)?.length ?? 0;
+  }
+  /** Remove all handlers */
+  clear() {
+    this.handlers.clear();
+  }
+};
+
+// src/core/hooks-engine.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_HOOK_OUTPUT = {
+  allow: true,
+  message: "",
+  metadata: {}
+};
+var HooksEngine = class {
+  constructor(eventBus2, processManager2) {
+    this.eventBus = eventBus2;
+    this.processManager = processManager2;
+  }
+  definitions = [];
+  registered = false;
+  /** Load hook definitions from config and register listeners on EventBus */
+  loadConfig(config) {
+    this.definitions = config.definitions.filter(
+      (def) => def.enabled !== false
+    );
+    if (!this.registered) {
+      for (const event of this.getUniqueEvents()) {
+        this.eventBus.on(event, async () => {
+        });
+      }
+      this.registered = true;
+    }
+  }
+  /** Emit a hook event and execute all matching hook definitions sequentially */
+  async emit(event, input) {
+    const matchingDefs = this.definitions.filter((def) => def.event === event);
+    const results = [];
+    for (const def of matchingDefs) {
+      try {
+        const result = await this.executeHook(def, input);
+        results.push(result);
+      } catch (error) {
+        const strategy = def.onError ?? "warn";
+        const message = error instanceof Error ? error.message : String(error);
+        if (strategy === "abort") {
+          throw new Error(
+            `Hook "${def.command}" failed (abort): ${message}`
+          );
+        }
+        if (strategy === "warn") {
+          logger.warn(
+            `Hook "${def.command}" failed (warn): ${message}`
+          );
+        }
+        results.push({
+          exitCode: 1,
+          stdout: "",
+          stderr: message,
+          durationMs: 0,
+          output: { ...DEFAULT_HOOK_OUTPUT }
+        });
+      }
+    }
+    await this.eventBus.emit(event, input);
+    return results;
+  }
+  /** Get the count of enabled definitions for a given event */
+  getDefinitionCount(event) {
+    return this.definitions.filter((def) => def.event === event).length;
+  }
+  async executeHook(def, input) {
+    const timeoutMs = def.timeout ?? DEFAULT_TIMEOUT_MS;
+    const stdinData = JSON.stringify(input);
+    const startTime = Date.now();
+    const result = await this.processManager.executeWithInput(
+      def.command,
+      def.args ?? [],
+      stdinData,
+      { timeout: timeoutMs }
+    );
+    const durationMs = Date.now() - startTime;
+    let output;
+    try {
+      const parsed = JSON.parse(result.stdout);
+      output = {
+        allow: typeof parsed.allow === "boolean" ? parsed.allow : true,
+        message: typeof parsed.message === "string" ? parsed.message : "",
+        metadata: typeof parsed.metadata === "object" && parsed.metadata !== null && !Array.isArray(parsed.metadata) ? parsed.metadata : {}
+      };
+    } catch {
+      output = { ...DEFAULT_HOOK_OUTPUT };
+    }
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      durationMs,
+      output
+    };
+  }
+  getUniqueEvents() {
+    return [...new Set(this.definitions.map((def) => def.event))];
+  }
+};
+
+// src/core/context-monitor.ts
+var DEFAULT_CONFIG = {
+  enabled: true,
+  thresholdPercent: 75,
+  notifyMethod: "stderr"
+};
+var ContextMonitor = class {
+  constructor(hooksEngine2, config) {
+    this.hooksEngine = hooksEngine2;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  config;
+  usageMap = /* @__PURE__ */ new Map();
+  /** Update token usage for a session and check threshold */
+  updateUsage(sessionId, backendId, estimatedTokens, maxTokens) {
+    if (!this.config.enabled) return;
+    const usagePercent = maxTokens > 0 ? Math.round(estimatedTokens / maxTokens * 100) : 0;
+    const existing = this.usageMap.get(sessionId);
+    const wasNotified = existing?.notified ?? false;
+    this.usageMap.set(sessionId, {
+      estimatedTokens,
+      maxTokens,
+      usagePercent,
+      backendId,
+      notified: wasNotified
+    });
+    if (usagePercent >= this.config.thresholdPercent && !wasNotified) {
+      this.usageMap.get(sessionId).notified = true;
+      this.notify(sessionId, backendId, usagePercent);
+    }
+  }
+  /** Get usage info for a session */
+  getUsage(sessionId) {
+    const entry = this.usageMap.get(sessionId);
+    if (!entry) return null;
+    return {
+      usagePercent: entry.usagePercent,
+      isEstimated: true
+    };
+  }
+  /** Remove usage tracking for a session */
+  removeSession(sessionId) {
+    this.usageMap.delete(sessionId);
+  }
+  notify(sessionId, backendId, usagePercent) {
+    if (this.config.notifyMethod === "stderr") {
+      process.stderr.write(
+        `[relay] Context usage warning: session ${sessionId} is at ${usagePercent}% (threshold: ${this.config.thresholdPercent}%)
+`
+      );
+    } else if (this.config.notifyMethod === "hook" && this.hooksEngine) {
+      const hookInput = {
+        event: "on-context-threshold",
+        sessionId,
+        backendId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          usagePercent,
+          thresholdPercent: this.config.thresholdPercent
+        }
+      };
+      void this.hooksEngine.emit("on-context-threshold", hookInput);
+    }
+  }
+};
+
+// src/commands/backend.ts
+import { defineCommand } from "citty";
+
+// src/adapters/install-guides.ts
+var INSTALL_GUIDES = {
+  claude: "Install: curl -fsSL https://claude.ai/install.sh | bash\n  Or: brew install --cask claude-code",
+  codex: "Install: npm install -g @openai/codex\n  Or: brew install --cask codex",
+  gemini: "Install: npm install -g @google/gemini-cli\n  Or: brew install gemini-cli"
+};
+
+// src/commands/backend.ts
+function createBackendCommand(backendId, registry2, sessionManager2, hooksEngine2) {
+  return defineCommand({
+    meta: {
+      name: backendId,
+      description: `Run ${backendId} CLI`
+    },
+    args: {
+      prompt: {
+        type: "string",
+        alias: "p",
+        description: "Execute a single prompt"
+      },
+      continue: {
+        type: "boolean",
+        alias: "c",
+        description: "Continue the most recent session"
+      },
+      resume: {
+        type: "string",
+        alias: "r",
+        description: "Resume a specific session by ID"
+      },
+      agent: {
+        type: "string",
+        description: "Agent configuration to use"
+      },
+      model: {
+        type: "string",
+        description: "Model to use"
+      },
+      maxTurns: {
+        type: "string",
+        description: "Maximum number of turns"
+      },
+      outputFormat: {
+        type: "string",
+        description: "Output format (text, json, stream-json)"
+      },
+      verbose: {
+        type: "boolean",
+        description: "Enable verbose output"
+      }
+    },
+    async run({ args }) {
+      const adapter = registry2.get(backendId);
+      const installed = await adapter.isInstalled();
+      if (!installed) {
+        logger.error(
+          `Backend "${backendId}" is not installed.
+  ${INSTALL_GUIDES[backendId]}`
+        );
+        process.exit(1);
+      }
+      const flags = {};
+      if (args.prompt) flags.prompt = args.prompt;
+      if (args.continue) flags.continue = true;
+      if (args.resume) flags.resume = args.resume;
+      if (args.agent) flags.agent = args.agent;
+      if (args.model) flags.model = args.model;
+      if (args.maxTurns) flags.maxTurns = Number(args.maxTurns);
+      if (args.outputFormat) {
+        flags.outputFormat = args.outputFormat;
+      }
+      if (args.verbose) flags.verbose = true;
+      let relaySessionId;
+      if (sessionManager2) {
+        try {
+          const session = await sessionManager2.create({ backendId });
+          relaySessionId = session.relaySessionId;
+          logger.debug(`Created relay session: ${relaySessionId}`);
+        } catch (error) {
+          logger.debug(
+            `Failed to create session: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (hooksEngine2 && relaySessionId) {
+        try {
+          const hookInput = {
+            event: "pre-prompt",
+            sessionId: relaySessionId,
+            backendId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            data: { prompt: flags.prompt }
+          };
+          await hooksEngine2.emit("pre-prompt", hookInput);
+        } catch (error) {
+          logger.debug(
+            `pre-prompt hook error: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      try {
+        if (flags.prompt) {
+          logger.debug(`Executing prompt on ${backendId}`);
+          const result = await adapter.execute(flags);
+          if (result.stdout) process.stdout.write(result.stdout);
+          if (result.stderr) process.stderr.write(result.stderr);
+          process.exitCode = result.exitCode;
+        } else if (flags.continue) {
+          logger.debug(`Continuing latest session on ${backendId}`);
+          if (sessionManager2) {
+            const latestSession = await sessionManager2.getLatest(backendId);
+            if (latestSession?.nativeSessionId) {
+              logger.debug(
+                `Found latest relay session: ${latestSession.relaySessionId} (native: ${latestSession.nativeSessionId})`
+              );
+            }
+          }
+          const sessions = await adapter.listNativeSessions();
+          if (sessions.length > 0) {
+            await adapter.resumeSession(sessions[0].nativeId, flags);
+          } else {
+            await adapter.startInteractive({ ...flags, continue: true });
+          }
+        } else if (flags.resume) {
+          logger.debug(`Resuming session ${flags.resume} on ${backendId}`);
+          await adapter.resumeSession(flags.resume, flags);
+        } else {
+          logger.debug(`Starting interactive session on ${backendId}`);
+          await adapter.startInteractive(flags);
+        }
+        if (sessionManager2 && relaySessionId) {
+          try {
+            await sessionManager2.update(relaySessionId, {
+              status: "completed"
+            });
+          } catch {
+          }
+        }
+        if (hooksEngine2 && relaySessionId) {
+          try {
+            const hookInput = {
+              event: "post-response",
+              sessionId: relaySessionId,
+              backendId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: { status: "completed" }
+            };
+            await hooksEngine2.emit("post-response", hookInput);
+          } catch (error) {
+            logger.debug(
+              `post-response hook error: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      } catch (error) {
+        if (sessionManager2 && relaySessionId) {
+          try {
+            await sessionManager2.update(relaySessionId, {
+              status: "error"
+            });
+          } catch {
+          }
+        }
+        if (hooksEngine2 && relaySessionId) {
+          try {
+            const hookInput = {
+              event: "on-error",
+              sessionId: relaySessionId,
+              backendId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: {
+                error: error instanceof Error ? error.message : String(error)
+              }
+            };
+            await hooksEngine2.emit("on-error", hookInput);
+          } catch {
+          }
+        }
+        throw error;
+      }
+    }
+  });
+}
+
+// src/commands/update.ts
+import { defineCommand as defineCommand2 } from "citty";
+function createUpdateCommand(registry2) {
+  return defineCommand2({
+    meta: {
+      name: "update",
+      description: "Update all installed backend CLI tools"
+    },
+    async run() {
+      const adapters = registry2.list();
+      if (adapters.length === 0) {
+        logger.warn("No backends registered");
+        return;
+      }
+      for (const adapter of adapters) {
+        const installed = await adapter.isInstalled();
+        if (!installed) {
+          logger.info(`Skipping ${adapter.id}: not installed`);
+          continue;
+        }
+        logger.info(`Updating ${adapter.id}...`);
+        try {
+          await adapter.update();
+        } catch (error) {
+          logger.error(
+            `Failed to update ${adapter.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    }
+  });
+}
+
+// src/commands/config.ts
+import { defineCommand as defineCommand3 } from "citty";
+function createConfigCommand(configManager2) {
+  return defineCommand3({
+    meta: {
+      name: "config",
+      description: "Manage relay configuration"
+    },
+    subCommands: {
+      get: defineCommand3({
+        meta: {
+          name: "get",
+          description: "Get a config value by key (dot-path notation)"
+        },
+        args: {
+          key: {
+            type: "positional",
+            description: "Config key (e.g. mcpServerMode.maxDepth)",
+            required: true
+          }
+        },
+        async run({ args }) {
+          const key = String(args.key);
+          const value = await configManager2.get(key);
+          if (value === void 0) {
+            logger.info(`Key "${key}" is not set`);
+          } else {
+            const output = typeof value === "object" ? JSON.stringify(value, null, 2) : String(value);
+            console.log(output);
+          }
+        }
+      }),
+      set: defineCommand3({
+        meta: {
+          name: "set",
+          description: "Set a config value (default: global scope)"
+        },
+        args: {
+          project: {
+            type: "boolean",
+            description: "Write to project scope instead of global"
+          },
+          key: {
+            type: "positional",
+            description: "Config key (e.g. defaultBackend)",
+            required: true
+          },
+          value: {
+            type: "positional",
+            description: "Config value",
+            required: true
+          }
+        },
+        async run({ args }) {
+          const scope = args.project ? "project" : "global";
+          const key = String(args.key);
+          const rawValue = String(args.value);
+          const parsed = parseValue(rawValue);
+          await configManager2.set(scope, key, parsed);
+          logger.success(`Set ${key} = ${JSON.stringify(parsed)} (${scope})`);
+        }
+      })
+    },
+    async run() {
+      const config = await configManager2.getConfig();
+      console.log(JSON.stringify(config, null, 2));
+    }
+  });
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  const num = Number(raw);
+  if (!Number.isNaN(num) && raw.trim() !== "") return num;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return raw;
+}
+
+// src/commands/mcp.ts
+import { defineCommand as defineCommand4 } from "citty";
+
+// src/mcp-server/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z5 } from "zod";
+
+// src/mcp-server/recursion-guard.ts
+import { createHash } from "crypto";
+var RecursionGuard = class {
+  constructor(config = {
+    maxDepth: 5,
+    maxCallsPerSession: 20,
+    timeoutSec: 300
+  }) {
+    this.config = config;
+  }
+  callCounts = /* @__PURE__ */ new Map();
+  promptHashes = /* @__PURE__ */ new Map();
+  /** Check if a spawn is allowed */
+  canSpawn(context) {
+    if (context.depth >= this.config.maxDepth) {
+      return {
+        allowed: false,
+        reason: `Max depth exceeded: ${context.depth} >= ${this.config.maxDepth}`
+      };
+    }
+    const currentCount = this.callCounts.get(context.traceId) ?? 0;
+    if (currentCount >= this.config.maxCallsPerSession) {
+      return {
+        allowed: false,
+        reason: `Max calls per session exceeded: ${currentCount} >= ${this.config.maxCallsPerSession}`
+      };
+    }
+    if (this.detectLoop(context.traceId, context.backend, context.promptHash)) {
+      return {
+        allowed: false,
+        reason: `Loop detected: same (backend=${context.backend}, promptHash=${context.promptHash}) appeared 3+ times in trace ${context.traceId}`
+      };
+    }
+    return { allowed: true };
+  }
+  /** Record a spawn invocation */
+  recordSpawn(context) {
+    const currentCount = this.callCounts.get(context.traceId) ?? 0;
+    this.callCounts.set(context.traceId, currentCount + 1);
+    const key = `${context.backend}:${context.promptHash}`;
+    const existing = this.promptHashes.get(context.traceId) ?? [];
+    existing.push(key);
+    this.promptHashes.set(context.traceId, existing);
+  }
+  /** Detect if the same (backend + promptHash) combination has appeared 3+ times */
+  detectLoop(traceId, backend, promptHash) {
+    const key = `${backend}:${promptHash}`;
+    const hashes = this.promptHashes.get(traceId) ?? [];
+    const count = hashes.filter((h) => h === key).length;
+    return count >= 3;
+  }
+  /** Get current config (for testing/inspection) */
+  getConfig() {
+    return { ...this.config };
+  }
+  /** Get call count for a trace */
+  getCallCount(traceId) {
+    return this.callCounts.get(traceId) ?? 0;
+  }
+  /** Utility: compute a prompt hash */
+  static hashPrompt(prompt) {
+    return createHash("sha256").update(prompt).digest("hex").slice(0, 16);
+  }
+};
+
+// src/mcp-server/tools/spawn-agent.ts
+import { z as z2 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+var spawnAgentInputSchema = z2.object({
+  backend: z2.enum(["claude", "codex", "gemini"]),
+  prompt: z2.string(),
+  agent: z2.string().optional(),
+  resumeSessionId: z2.string().optional(),
+  model: z2.string().optional(),
+  maxTurns: z2.number().optional()
+});
+function buildContextFromEnv() {
+  const traceId = process.env["RELAY_TRACE_ID"] ?? `trace-${nanoid2()}`;
+  const parentSessionId = process.env["RELAY_PARENT_SESSION_ID"] ?? null;
+  const depth = Number(process.env["RELAY_DEPTH"] ?? "0");
+  return { traceId, parentSessionId, depth };
+}
+async function executeSpawnAgent(input, registry2, sessionManager2, guard, hooksEngine2) {
+  const envContext = buildContextFromEnv();
+  const promptHash = RecursionGuard.hashPrompt(input.prompt);
+  const context = {
+    traceId: envContext.traceId,
+    depth: envContext.depth,
+    backend: input.backend,
+    promptHash
+  };
+  const guardResult = guard.canSpawn(context);
+  if (!guardResult.allowed) {
+    logger.warn(`Spawn blocked by RecursionGuard: ${guardResult.reason}`);
+    return {
+      sessionId: "",
+      exitCode: 1,
+      stdout: "",
+      stderr: `Spawn blocked: ${guardResult.reason}`
+    };
+  }
+  const adapter = registry2.get(input.backend);
+  const installed = await adapter.isInstalled();
+  if (!installed) {
+    return {
+      sessionId: "",
+      exitCode: 1,
+      stdout: "",
+      stderr: `Backend "${input.backend}" is not installed`
+    };
+  }
+  const session = await sessionManager2.create({
+    backendId: input.backend,
+    parentSessionId: envContext.parentSessionId ?? void 0,
+    depth: envContext.depth + 1
+  });
+  if (hooksEngine2) {
+    try {
+      const hookInput = {
+        event: "pre-spawn",
+        sessionId: session.relaySessionId,
+        backendId: input.backend,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        data: {
+          prompt: input.prompt,
+          agent: input.agent,
+          model: input.model
+        }
+      };
+      await hooksEngine2.emit("pre-spawn", hookInput);
+    } catch (error) {
+      logger.debug(
+        `pre-spawn hook error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  try {
+    const result = await adapter.execute({
+      prompt: input.prompt,
+      agent: input.agent,
+      model: input.model,
+      maxTurns: input.maxTurns,
+      resume: input.resumeSessionId,
+      mcpContext: {
+        parentSessionId: session.relaySessionId,
+        depth: envContext.depth + 1,
+        maxDepth: guard.getConfig().maxDepth,
+        traceId: envContext.traceId
+      }
+    });
+    guard.recordSpawn(context);
+    const status = result.exitCode === 0 ? "completed" : "error";
+    await sessionManager2.update(session.relaySessionId, { status });
+    if (hooksEngine2) {
+      try {
+        const hookInput = {
+          event: "post-spawn",
+          sessionId: session.relaySessionId,
+          backendId: input.backend,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            exitCode: result.exitCode,
+            status
+          }
+        };
+        await hooksEngine2.emit("post-spawn", hookInput);
+      } catch (hookError) {
+        logger.debug(
+          `post-spawn hook error: ${hookError instanceof Error ? hookError.message : String(hookError)}`
+        );
+      }
+    }
+    return {
+      sessionId: session.relaySessionId,
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    await sessionManager2.update(session.relaySessionId, { status: "error" });
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      sessionId: session.relaySessionId,
+      exitCode: 1,
+      stdout: "",
+      stderr: message
+    };
+  }
+}
+
+// src/mcp-server/tools/list-sessions.ts
+import { z as z3 } from "zod";
+var listSessionsInputSchema = z3.object({
+  backend: z3.enum(["claude", "codex", "gemini"]).optional(),
+  limit: z3.number().optional().default(10)
+});
+async function executeListSessions(input, sessionManager2) {
+  const sessions = await sessionManager2.list({
+    backendId: input.backend,
+    limit: input.limit
+  });
+  return {
+    sessions: sessions.map((s) => ({
+      relaySessionId: s.relaySessionId,
+      backendId: s.backendId,
+      status: s.status,
+      createdAt: s.createdAt.toISOString()
+    }))
+  };
+}
+
+// src/mcp-server/tools/get-context-status.ts
+import { z as z4 } from "zod";
+var getContextStatusInputSchema = z4.object({
+  sessionId: z4.string()
+});
+async function executeGetContextStatus(input, sessionManager2, contextMonitor2) {
+  const session = await sessionManager2.get(input.sessionId);
+  if (!session) {
+    throw new Error(`Session not found: ${input.sessionId}`);
+  }
+  if (contextMonitor2) {
+    const usage = contextMonitor2.getUsage(input.sessionId);
+    if (usage) {
+      return {
+        sessionId: input.sessionId,
+        usagePercent: usage.usagePercent,
+        isEstimated: usage.isEstimated
+      };
+    }
+  }
+  return {
+    sessionId: input.sessionId,
+    usagePercent: 0,
+    isEstimated: true
+  };
+}
+
+// src/mcp-server/server.ts
+var RelayMCPServer = class {
+  constructor(registry2, sessionManager2, guardConfig, hooksEngine2, contextMonitor2) {
+    this.registry = registry2;
+    this.sessionManager = sessionManager2;
+    this.hooksEngine = hooksEngine2;
+    this.contextMonitor = contextMonitor2;
+    this.guard = new RecursionGuard(guardConfig);
+    this.server = new McpServer({
+      name: "agentic-relay",
+      version: "0.1.0"
+    });
+    this.registerTools();
+  }
+  server;
+  guard;
+  registerTools() {
+    this.server.tool(
+      "spawn_agent",
+      "Spawn a sub-agent on the specified backend CLI (Claude Code, Codex CLI, or Gemini CLI). The agent executes the given prompt in non-interactive mode and returns the result.",
+      {
+        backend: z5.enum(["claude", "codex", "gemini"]),
+        prompt: z5.string(),
+        agent: z5.string().optional(),
+        resumeSessionId: z5.string().optional(),
+        model: z5.string().optional(),
+        maxTurns: z5.number().optional()
+      },
+      async (params) => {
+        try {
+          const result = await executeSpawnAgent(
+            params,
+            this.registry,
+            this.sessionManager,
+            this.guard,
+            this.hooksEngine
+          );
+          const isError = result.exitCode !== 0;
+          const text = isError ? `Error (exit ${result.exitCode}): ${result.stderr || result.stdout}` : `Session: ${result.sessionId}
+
+${result.stdout}`;
+          return {
+            content: [{ type: "text", text }],
+            isError
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "list_sessions",
+      "List relay sessions, optionally filtered by backend.",
+      {
+        backend: z5.enum(["claude", "codex", "gemini"]).optional(),
+        limit: z5.number().optional()
+      },
+      async (params) => {
+        try {
+          const result = await executeListSessions(
+            { backend: params.backend, limit: params.limit ?? 10 },
+            this.sessionManager
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.tool(
+      "get_context_status",
+      "Get the context usage status of a relay session. Returns usage data from ContextMonitor when available, otherwise estimated values.",
+      {
+        sessionId: z5.string()
+      },
+      async (params) => {
+        try {
+          const result = await executeGetContextStatus(
+            params,
+            this.sessionManager,
+            this.contextMonitor
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  async start() {
+    logger.info("Starting agentic-relay MCP server (stdio transport)...");
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+  }
+};
+
+// src/commands/mcp.ts
+function createMCPCommand(configManager2, registry2, sessionManager2, hooksEngine2, contextMonitor2) {
+  return defineCommand4({
+    meta: {
+      name: "mcp",
+      description: "Manage MCP server configuration"
+    },
+    subCommands: {
+      list: defineCommand4({
+        meta: {
+          name: "list",
+          description: "List configured MCP servers"
+        },
+        async run() {
+          const config = await configManager2.getConfig();
+          const servers = config.mcpServers ?? {};
+          const entries = Object.entries(servers);
+          if (entries.length === 0) {
+            logger.info("No MCP servers configured");
+            return;
+          }
+          console.log("MCP Servers:");
+          console.log(
+            "%-20s %-20s %s",
+            "NAME",
+            "COMMAND",
+            "ARGS"
+          );
+          console.log("-".repeat(60));
+          for (const [name, server] of entries) {
+            const args = server.args?.join(" ") ?? "";
+            console.log(
+              "%-20s %-20s %s",
+              name,
+              server.command,
+              args
+            );
+          }
+        }
+      }),
+      add: defineCommand4({
+        meta: {
+          name: "add",
+          description: "Add an MCP server (usage: relay mcp add <name> -- <command> [args...])"
+        },
+        args: {
+          name: {
+            type: "positional",
+            description: "Server name",
+            required: true
+          },
+          _: {
+            type: "positional",
+            description: "Command and args (after --)",
+            required: false
+          }
+        },
+        async run({ args }) {
+          const name = String(args.name);
+          const rawArgs = process.argv;
+          const doubleDashIndex = rawArgs.indexOf("--");
+          if (doubleDashIndex === -1 || doubleDashIndex >= rawArgs.length - 1) {
+            logger.error(
+              "Usage: relay mcp add <name> -- <command> [args...]"
+            );
+            process.exitCode = 1;
+            return;
+          }
+          const commandArgs = rawArgs.slice(doubleDashIndex + 1);
+          const command = commandArgs[0];
+          const serverArgs = commandArgs.slice(1);
+          const server = {
+            name,
+            command,
+            ...serverArgs.length > 0 ? { args: serverArgs } : {}
+          };
+          await configManager2.set("global", `mcpServers.${name}`, server);
+          logger.success(`Added MCP server "${name}"`);
+        }
+      }),
+      remove: defineCommand4({
+        meta: {
+          name: "remove",
+          description: "Remove an MCP server"
+        },
+        args: {
+          name: {
+            type: "positional",
+            description: "Server name to remove",
+            required: true
+          }
+        },
+        async run({ args }) {
+          const name = String(args.name);
+          const config = await configManager2.getConfig();
+          const servers = config.mcpServers ?? {};
+          if (!(name in servers)) {
+            logger.error(`MCP server "${name}" not found`);
+            process.exitCode = 1;
+            return;
+          }
+          const globalConfig = await configManager2.getConfigByScope("global");
+          const mcpServers = globalConfig.mcpServers ?? {};
+          delete mcpServers[name];
+          await configManager2.set("global", "mcpServers", mcpServers);
+          logger.success(`Removed MCP server "${name}"`);
+        }
+      }),
+      sync: defineCommand4({
+        meta: {
+          name: "sync",
+          description: "Sync MCP config to all backend CLI tools"
+        },
+        async run() {
+          await configManager2.syncMCPConfig(registry2);
+          logger.success("MCP config sync complete");
+        }
+      }),
+      serve: defineCommand4({
+        meta: {
+          name: "serve",
+          description: "Start relay as an MCP server (stdio transport)"
+        },
+        async run() {
+          if (!sessionManager2) {
+            logger.error("SessionManager is required for MCP server mode");
+            process.exitCode = 1;
+            return;
+          }
+          let guardConfig;
+          try {
+            const config = await configManager2.getConfig();
+            if (config.mcpServerMode) {
+              guardConfig = {
+                maxDepth: config.mcpServerMode.maxDepth ?? 5,
+                maxCallsPerSession: config.mcpServerMode.maxCallsPerSession ?? 20,
+                timeoutSec: config.mcpServerMode.timeoutSec ?? 300
+              };
+            }
+          } catch {
+          }
+          const server = new RelayMCPServer(
+            registry2,
+            sessionManager2,
+            guardConfig,
+            hooksEngine2,
+            contextMonitor2
+          );
+          await server.start();
+        }
+      })
+    },
+    async run() {
+      logger.info(
+        "Usage: relay mcp <list|add|remove|sync|serve>. Run relay mcp --help for details."
+      );
+    }
+  });
+}
+
+// src/commands/auth.ts
+import { defineCommand as defineCommand5 } from "citty";
+function createBackendAuthCommand(backendId, authManager2) {
+  return defineCommand5({
+    meta: {
+      name: backendId,
+      description: `Manage ${backendId} authentication`
+    },
+    args: {
+      action: {
+        type: "string",
+        description: "Auth action: login, logout, or status",
+        required: true
+      }
+    },
+    async run({ args }) {
+      const action = args.action;
+      if (!["login", "logout", "status"].includes(action)) {
+        logger.error(
+          `Invalid auth action "${action}". Use login, logout, or status.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      await authManager2.auth(backendId, action);
+    }
+  });
+}
+function createAuthCommand(authManager2) {
+  return defineCommand5({
+    meta: {
+      name: "auth",
+      description: "Manage backend authentication"
+    },
+    subCommands: {
+      claude: createBackendAuthCommand("claude", authManager2),
+      codex: createBackendAuthCommand("codex", authManager2),
+      gemini: createBackendAuthCommand("gemini", authManager2),
+      status: defineCommand5({
+        meta: {
+          name: "status",
+          description: "Show auth status for all backends"
+        },
+        async run() {
+          await authManager2.statusAll();
+        }
+      })
+    },
+    async run() {
+      await authManager2.statusAll();
+    }
+  });
+}
+
+// src/commands/sessions.ts
+import { defineCommand as defineCommand6 } from "citty";
+function formatDate(date) {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}`;
+}
+function padRight(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function createSessionsCommand(sessionManager2) {
+  return defineCommand6({
+    meta: {
+      name: "sessions",
+      description: "List and search relay sessions"
+    },
+    args: {
+      backend: {
+        type: "string",
+        description: "Filter by backend (claude, codex, gemini)"
+      },
+      limit: {
+        type: "string",
+        description: "Maximum number of sessions to display (default: 10)"
+      },
+      search: {
+        type: "string",
+        description: "Search sessions by keyword"
+      }
+    },
+    async run({ args }) {
+      const backendId = args.backend;
+      const limit = args.limit ? Number(args.limit) : 10;
+      const search = args.search;
+      if (backendId && !["claude", "codex", "gemini"].includes(backendId)) {
+        logger.error(
+          `Invalid backend "${backendId}". Available: claude, codex, gemini`
+        );
+        process.exit(1);
+      }
+      if (args.limit && (isNaN(limit) || limit <= 0)) {
+        logger.error("--limit must be a positive number");
+        process.exit(1);
+      }
+      try {
+        let sessions = await sessionManager2.list({
+          backendId
+        });
+        if (search) {
+          const keyword = search.toLowerCase();
+          sessions = sessions.filter((s) => {
+            return s.relaySessionId.toLowerCase().includes(keyword) || s.backendId.toLowerCase().includes(keyword) || s.status.toLowerCase().includes(keyword) || (s.parentSessionId?.toLowerCase().includes(keyword) ?? false);
+          });
+        }
+        sessions = sessions.slice(0, limit);
+        if (sessions.length === 0) {
+          logger.info("No sessions found.");
+          return;
+        }
+        const header = `${padRight("ID", 24)}${padRight("Backend", 10)}${padRight("Status", 12)}${padRight("Created", 21)}Parent`;
+        console.log(header);
+        for (const session of sessions) {
+          const id = padRight(session.relaySessionId, 24);
+          const backend = padRight(session.backendId, 10);
+          const status = padRight(session.status, 12);
+          const created = padRight(formatDate(session.createdAt), 21);
+          const parent = session.parentSessionId ?? "-";
+          console.log(`${id}${backend}${status}${created}${parent}`);
+        }
+      } catch (error) {
+        logger.error(
+          `Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`
+        );
+        process.exit(1);
+      }
+    }
+  });
+}
+
+// src/commands/version.ts
+import { defineCommand as defineCommand7 } from "citty";
+function createVersionCommand(registry2) {
+  return defineCommand7({
+    meta: {
+      name: "version",
+      description: "Show relay and backend versions"
+    },
+    async run() {
+      const relayVersion = "0.1.0";
+      console.log(`agentic-relay v${relayVersion}`);
+      console.log("");
+      console.log("Backends:");
+      const adapters = registry2.list();
+      for (const adapter of adapters) {
+        const installed = await adapter.isInstalled();
+        if (installed) {
+          try {
+            const version = await adapter.getVersion();
+            console.log(`  ${adapter.id}  ${version}  installed`);
+          } catch {
+            console.log(`  ${adapter.id}  (version unknown)  installed`);
+          }
+        } else {
+          console.log(`  ${adapter.id}  -  not installed`);
+        }
+      }
+    }
+  });
+}
+
+// src/commands/doctor.ts
+import { defineCommand as defineCommand8 } from "citty";
+import { access, constants } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+async function checkNodeVersion() {
+  const version = process.version;
+  const major = Number(version.slice(1).split(".")[0]);
+  const ok = major >= 22;
+  return {
+    label: "Node.js",
+    ok,
+    detail: ok ? `Node.js ${version}` : `Node.js ${version} (requires >= 22)`,
+    hint: ok ? void 0 : "Upgrade Node.js to version 22 or later"
+  };
+}
+async function checkBackend(registry2, backendId) {
+  const adapter = registry2.get(backendId);
+  const installed = await adapter.isInstalled();
+  if (!installed) {
+    return {
+      label: backendId,
+      ok: false,
+      detail: `${backendId} not installed`,
+      hint: INSTALL_GUIDES[backendId]
+    };
+  }
+  try {
+    const version = await adapter.getVersion();
+    return {
+      label: backendId,
+      ok: true,
+      detail: `${backendId} ${version}`
+    };
+  } catch {
+    return {
+      label: backendId,
+      ok: true,
+      detail: `${backendId} installed (version unknown)`
+    };
+  }
+}
+async function checkConfig(configManager2) {
+  try {
+    const config = await configManager2.getConfig();
+    const hasContent = Object.keys(config).length > 0;
+    return {
+      label: "Config",
+      ok: true,
+      detail: hasContent ? "Config loaded (valid)" : "Config: default (no config file)"
+    };
+  } catch (error) {
+    return {
+      label: "Config",
+      ok: false,
+      detail: `Config error: ${error instanceof Error ? error.message : String(error)}`,
+      hint: 'Run "relay init" to create a default config'
+    };
+  }
+}
+async function checkSessionsDir() {
+  const relayHome2 = process.env["RELAY_HOME"] ?? join3(homedir2(), ".relay");
+  const sessionsDir = join3(relayHome2, "sessions");
+  try {
+    await access(sessionsDir, constants.W_OK);
+    return {
+      label: "Sessions directory",
+      ok: true,
+      detail: `${sessionsDir} (writable)`
+    };
+  } catch {
+    return {
+      label: "Sessions directory",
+      ok: false,
+      detail: `${sessionsDir} (not writable or missing)`,
+      hint: `Create directory: mkdir -p ${sessionsDir}`
+    };
+  }
+}
+async function checkMCPSDK() {
+  try {
+    await import("@modelcontextprotocol/sdk/server/mcp.js");
+    return {
+      label: "MCP SDK",
+      ok: true,
+      detail: "MCP SDK available"
+    };
+  } catch {
+    return {
+      label: "MCP SDK",
+      ok: false,
+      detail: "MCP SDK not available",
+      hint: "Install: pnpm add @modelcontextprotocol/sdk"
+    };
+  }
+}
+function createDoctorCommand(registry2, configManager2) {
+  return defineCommand8({
+    meta: {
+      name: "doctor",
+      description: "Run environment diagnostics"
+    },
+    async run() {
+      console.log("Environment Check:");
+      const checks = [];
+      checks.push(await checkNodeVersion());
+      const backendIds = ["claude", "codex", "gemini"];
+      for (const id of backendIds) {
+        checks.push(await checkBackend(registry2, id));
+      }
+      checks.push(await checkConfig(configManager2));
+      checks.push(await checkSessionsDir());
+      checks.push(await checkMCPSDK());
+      let hasFailures = false;
+      for (const check of checks) {
+        const icon = check.ok ? "\u2713" : "\u2717";
+        console.log(`  ${icon} ${check.detail}`);
+        if (!check.ok) {
+          hasFailures = true;
+          if (check.hint) {
+            console.log(`    ${check.hint}`);
+          }
+        }
+      }
+      if (hasFailures) {
+        console.log("");
+        console.log("Some checks failed. Resolve the issues above.");
+        process.exitCode = 1;
+      } else {
+        console.log("");
+        console.log("All checks passed.");
+      }
+    }
+  });
+}
+
+// src/commands/init.ts
+import { defineCommand as defineCommand9 } from "citty";
+import { mkdir as mkdir3, writeFile as writeFile3, access as access2, readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+var DEFAULT_CONFIG2 = {
+  defaultBackend: "claude",
+  backends: {},
+  mcpServers: {}
+};
+function createInitCommand() {
+  return defineCommand9({
+    meta: {
+      name: "init",
+      description: "Initialize relay configuration in the current project"
+    },
+    async run() {
+      const projectDir = process.cwd();
+      const relayDir = join4(projectDir, ".relay");
+      const configPath = join4(relayDir, "config.json");
+      try {
+        await access2(relayDir);
+        logger.info(
+          `.relay/ already exists at ${relayDir}. Skipping initialization.`
+        );
+        return;
+      } catch {
+      }
+      await mkdir3(relayDir, { recursive: true });
+      await writeFile3(
+        configPath,
+        JSON.stringify(DEFAULT_CONFIG2, null, 2) + "\n",
+        "utf-8"
+      );
+      logger.success(`Created ${configPath}`);
+      const gitignorePath = join4(projectDir, ".gitignore");
+      try {
+        const gitignoreContent = await readFile3(gitignorePath, "utf-8");
+        if (!gitignoreContent.includes(".relay/config.local.json")) {
+          logger.info(
+            'Tip: Add ".relay/config.local.json" to your .gitignore to keep local config out of version control.'
+          );
+        }
+      } catch {
+        logger.info(
+          'Tip: Add ".relay/config.local.json" to your .gitignore to keep local config out of version control.'
+        );
+      }
+      logger.success("Relay project initialized.");
+    }
+  });
+}
+
+// src/bin/relay.ts
+var processManager = new ProcessManager();
+var registry = new AdapterRegistry();
+registry.register(new ClaudeAdapter(processManager));
+registry.register(new CodexAdapter(processManager));
+registry.register(new GeminiAdapter(processManager));
+var sessionManager = new SessionManager();
+var relayHome = process.env["RELAY_HOME"] ?? join5(homedir3(), ".relay");
+var projectRelayDir = join5(process.cwd(), ".relay");
+var configManager = new ConfigManager(relayHome, projectRelayDir);
+var authManager = new AuthManager(registry);
+var eventBus = new EventBus();
+var hooksEngine = new HooksEngine(eventBus, processManager);
+var contextMonitor = new ContextMonitor(hooksEngine, {
+  enabled: false
+  // Will be enabled from config at runtime
+});
+void configManager.getConfig().then((config) => {
+  if (config.hooks) {
+    hooksEngine.loadConfig(config.hooks);
+  }
+  if (config.contextMonitor) {
+  }
+}).catch(() => {
+});
+var main = defineCommand10({
+  meta: {
+    name: "relay",
+    version: "0.1.0",
+    description: "Unified CLI proxy for Claude Code, Codex CLI, and Gemini CLI"
+  },
+  subCommands: {
+    claude: createBackendCommand("claude", registry, sessionManager, hooksEngine),
+    codex: createBackendCommand("codex", registry, sessionManager, hooksEngine),
+    gemini: createBackendCommand("gemini", registry, sessionManager, hooksEngine),
+    update: createUpdateCommand(registry),
+    config: createConfigCommand(configManager),
+    mcp: createMCPCommand(configManager, registry, sessionManager, hooksEngine, contextMonitor),
+    auth: createAuthCommand(authManager),
+    sessions: createSessionsCommand(sessionManager),
+    version: createVersionCommand(registry),
+    doctor: createDoctorCommand(registry, configManager),
+    init: createInitCommand()
+  }
+});
+runMain(main);