agent-relay 2.0.29 → 2.0.32

package/packages/config/src/schemas.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+const withId = (schema: unknown, id: string) =>
+  Object.assign(schema as Record<string, unknown>, { $id: id });
+
+// Relay connection defaults (used by daemon + wrapper)
+export const ConnectionConfigSchema = z.object({
+  maxFrameBytes: z.number().int().positive(),
+  heartbeatMs: z.number().int().positive(),
+  heartbeatTimeoutMultiplier: z.number().int().positive(),
+  maxWriteQueueSize: z.number().int().nonnegative(),
+  writeQueueHighWaterMark: z.number().int().nonnegative(),
+  writeQueueLowWaterMark: z.number().int().nonnegative(),
+});
+
+export const TmuxWrapperConfigSchema = z.object({
+  pollInterval: z.number().int().positive(),
+  idleBeforeInjectMs: z.number().int().nonnegative(),
+  injectRetryMs: z.number().int().nonnegative(),
+  debug: z.boolean(),
+  debugLogIntervalMs: z.number().int().nonnegative(),
+  mouseMode: z.boolean(),
+  activityIdleThresholdMs: z.number().int().nonnegative(),
+  outputStabilityTimeoutMs: z.number().int().nonnegative(),
+  outputStabilityPollMs: z.number().int().nonnegative(),
+  streamLogs: z.boolean(),
+});
+
+export const RelayRuntimeConfigSchema = z.object({
+  trajectories: z
+    .object({
+      storeInRepo: z.boolean().optional(),
+    })
+    .optional(),
+});
+
+export const BridgeConfigSchema = z.object({
+  projects: z
+    .record(
+      z.object({
+        lead: z.string().optional(),
+        cli: z.string().optional(),
+      })
+    )
+    .optional(),
+  defaultCli: z.string().optional(),
+});
+
+export const TeamsConfigSchema = z.object({
+  team: z.string(),
+  agents: z
+    .array(
+      z.object({
+        name: z.string(),
+        cli: z.string(),
+        role: z.string().optional(),
+        task: z.string().optional(),
+      })
+    )
+    .default([]),
+  autoSpawn: z.boolean().optional(),
+});
+
+export const ShadowRoleConfigSchema = z.object({
+  prompt: z.string().optional(),
+  speakOn: z.array(z.string()).default([]),
+});
+
+export const ShadowPairConfigSchema = z.object({
+  shadow: z.string(),
+  shadowRole: z.string().optional(),
+  speakOn: z.array(z.string()).optional(),
+});
+
+export const ShadowConfigSchema = z.object({
+  shadows: z
+    .object({
+      pairs: z.record(ShadowPairConfigSchema).optional(),
+      roles: z.record(ShadowRoleConfigSchema).optional(),
+    })
+    .optional(),
+});
+
+export const AgentFrontmatterSchema = z.object({
+  name: z.string().optional(),
+  model: z.string().optional(),
+  description: z.string().optional(),
+  agentType: z.string().optional(),
+  role: z.string().optional(),
+  'allowed-tools': z.string().optional(),
+});
+
+export const CLIAuthConfigSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()),
+  deviceFlowArgs: z.array(z.string()).optional(),
+  urlPattern: z.instanceof(RegExp),
+  credentialPath: z.string().optional(),
+  displayName: z.string(),
+  prompts: z
+    .array(
+      z.object({
+        pattern: z.instanceof(RegExp),
+        response: z.string(),
+        delay: z.number().int().nonnegative().optional(),
+        description: z.string(),
+      })
+    )
+    .default([]),
+  successPatterns: z.array(z.instanceof(RegExp)).default([]),
+  errorPatterns: z
+    .array(
+      z.object({
+        pattern: z.instanceof(RegExp),
+        message: z.string(),
+        recoverable: z.boolean(),
+        hint: z.string().optional(),
+      })
+    )
+    .optional(),
+  waitTimeout: z.number().int().nonnegative(),
+  supportsDeviceFlow: z.boolean().optional(),
+});
+
+export const CloudConfigSchema = z.object({
+  port: z.number().int(),
+  publicUrl: z.string(),
+  appUrl: z.string(),
+  sessionSecret: z.string(),
+  localDashboardUrl: z.string().optional(),
+  databaseUrl: z.string(),
+  redisUrl: z.string(),
+  github: z.object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+    webhookSecret: z.string().optional(),
+  }),
+  providers: z
+    .object({
+      anthropic: z.object({ clientId: z.string() }).optional(),
+      openai: z.object({ clientId: z.string() }).optional(),
+      google: z
+        .object({
+          clientId: z.string(),
+          clientSecret: z.string(),
+        })
+        .optional(),
+    })
+    .default({}),
+  vault: z.object({
+    masterKey: z.string(),
+  }),
+  compute: z.object({
+    provider: z.enum(['fly', 'railway', 'docker']),
+    fly: z
+      .object({
+        apiToken: z.string(),
+        org: z.string(),
+        region: z.string().optional(),
+        workspaceDomain: z.string().optional(),
+        registryAuth: z
+          .object({
+            username: z.string(),
+            password: z.string(),
+          })
+          .optional(),
+        snapshotRetentionDays: z.number().int().optional(),
+        volumeSizeGb: z.number().int().optional(),
+      })
+      .optional(),
+    railway: z
+      .object({
+        apiToken: z.string(),
+      })
+      .optional(),
+  }),
+  nango: z.object({
+    secretKey: z.string(),
+    host: z.string().optional(),
+  }),
+  stripe: z.object({
+    secretKey: z.string(),
+    publishableKey: z.string(),
+    webhookSecret: z.string(),
+    priceIds: z.record(z.string().optional()),
+  }),
+  adminUsers: z.array(z.string()),
+});
+
+export const jsonSchemas = {
+  connection: withId(zodToJsonSchema(ConnectionConfigSchema, { target: 'jsonSchema7' }), 'RelayConnectionConfig'),
+  tmuxWrapper: withId(zodToJsonSchema(TmuxWrapperConfigSchema, { target: 'jsonSchema7' }), 'RelayTmuxWrapperConfig'),
+  relayRuntime: withId(zodToJsonSchema(RelayRuntimeConfigSchema, { target: 'jsonSchema7' }), 'RelayRuntimeConfig'),
+  bridge: withId(zodToJsonSchema(BridgeConfigSchema, { target: 'jsonSchema7' }), 'BridgeConfig'),
+  teams: withId(zodToJsonSchema(TeamsConfigSchema, { target: 'jsonSchema7' }), 'TeamsConfig'),
+  shadow: withId(zodToJsonSchema(ShadowConfigSchema, { target: 'jsonSchema7' }), 'ShadowConfig'),
+  agentFrontmatter: withId(zodToJsonSchema(AgentFrontmatterSchema, { target: 'jsonSchema7' }), 'AgentFrontmatter'),
+  cliAuth: withId(zodToJsonSchema(CLIAuthConfigSchema, { target: 'jsonSchema7' }), 'CLIAuthConfig'),
+  cloud: withId(zodToJsonSchema(CloudConfigSchema, { target: 'jsonSchema7' }), 'CloudConfig'),
+};

package/packages/config/src/shadow-config.ts

@@ -0,0 +1,205 @@
+/**
+ * Shadow Agent Configuration
+ * Handles loading and parsing shadow agent configuration from .agent-relay.json.
+ *
+ * Configuration can be placed in:
+ * - Project root: ./.agent-relay.json
+ * - Agent-relay dir: ./.agent-relay/config.json
+ *
+ * Shadow configuration structure:
+ * {
+ *   "shadows": {
+ *     "pairs": {
+ *       "Lead": { "shadow": "Auditor", "shadowRole": "reviewer" }
+ *     },
+ *     "roles": {
+ *       "reviewer": { "prompt": "Review code...", "speakOn": ["CODE_WRITTEN"] }
+ *     }
+ *   }
+ * }
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import type { SpeakOnTrigger } from '@agent-relay/protocol/types';
+
+/** Shadow role definition */
+export interface ShadowRoleConfig {
+  /** System prompt for this shadow role */
+  prompt?: string;
+  /** Triggers for when the shadow should speak */
+  speakOn: SpeakOnTrigger[];
+}
+
+/** Shadow pair definition */
+export interface ShadowPairConfig {
+  /** Name of the shadow agent */
+  shadow: string;
+  /** Role name (references roles config) or preset (reviewer, auditor, active) */
+  shadowRole?: string;
+  /** Override speakOn triggers (takes precedence over role) */
+  speakOn?: SpeakOnTrigger[];
+  /** CLI to use for shadow (defaults to same as primary) */
+  cli?: string;
+}
+
+/** Shadow configuration section */
+export interface ShadowConfig {
+  /** Primary -> Shadow mappings */
+  pairs: Record<string, ShadowPairConfig>;
+  /** Role definitions */
+  roles?: Record<string, ShadowRoleConfig>;
+}
+
+/** Full agent-relay configuration file structure */
+export interface AgentRelayConfig {
+  /** Shadow agent configuration */
+  shadows?: ShadowConfig;
+  /** Future config sections can be added here */
+}
+
+/** Resolved shadow config for a primary agent */
+export interface ResolvedShadowConfig {
+  /** Shadow agent name */
+  shadowName: string;
+  /** Role name (for logging/display) */
+  roleName?: string;
+  /** Resolved speakOn triggers */
+  speakOn: SpeakOnTrigger[];
+  /** System prompt for the shadow */
+  prompt?: string;
+  /** CLI to use for shadow */
+  cli?: string;
+}
+
+/** Role presets matching CLI behavior */
+const ROLE_PRESETS: Record<string, SpeakOnTrigger[]> = {
+  reviewer: ['CODE_WRITTEN', 'REVIEW_REQUEST', 'EXPLICIT_ASK'],
+  auditor: ['SESSION_END', 'EXPLICIT_ASK'],
+  active: ['ALL_MESSAGES'],
+};
+
+/**
+ * Possible locations for .agent-relay.json (in order of precedence)
+ */
+function getConfigPaths(projectRoot: string): string[] {
+  return [
+    path.join(projectRoot, '.agent-relay', 'config.json'),
+    path.join(projectRoot, '.agent-relay.json'),
+  ];
+}
+
+/**
+ * Load agent-relay configuration from project root
+ * Returns null if no config found
+ */
+export function loadAgentRelayConfig(projectRoot: string): AgentRelayConfig | null {
+  const configPaths = getConfigPaths(projectRoot);
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content) as AgentRelayConfig;
+
+        console.log(`[shadow-config] Loaded config from ${configPath}`);
+        return config;
+      } catch (err) {
+        console.error(`[shadow-config] Failed to parse ${configPath}:`, err);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get shadow configuration for a primary agent
+ * Returns null if no shadow configured for this agent
+ */
+export function getShadowForAgent(
+  projectRoot: string,
+  primaryAgentName: string
+): ResolvedShadowConfig | null {
+  const config = loadAgentRelayConfig(projectRoot);
+  if (!config?.shadows?.pairs) {
+    return null;
+  }
+
+  const pairConfig = config.shadows.pairs[primaryAgentName];
+  if (!pairConfig) {
+    return null;
+  }
+
+  // Resolve speakOn triggers
+  let speakOn: SpeakOnTrigger[] = ['EXPLICIT_ASK']; // Default
+  let prompt: string | undefined;
+  const roleName = pairConfig.shadowRole;
+
+  // First, try to resolve from role preset
+  if (roleName && ROLE_PRESETS[roleName.toLowerCase()]) {
+    speakOn = ROLE_PRESETS[roleName.toLowerCase()];
+  }
+
+  // Then, try custom role from config
+  if (roleName && config.shadows.roles?.[roleName]) {
+    const roleConfig = config.shadows.roles[roleName];
+    speakOn = roleConfig.speakOn;
+    prompt = roleConfig.prompt;
+  }
+
+  // Finally, override with explicit speakOn if provided
+  if (pairConfig.speakOn && pairConfig.speakOn.length > 0) {
+    speakOn = pairConfig.speakOn;
+  }
+
+  return {
+    shadowName: pairConfig.shadow,
+    roleName,
+    speakOn,
+    prompt,
+    cli: pairConfig.cli,
+  };
+}
+
+/**
+ * Get all configured shadow pairs
+ */
+export function getAllShadowPairs(projectRoot: string): Map<string, ResolvedShadowConfig> {
+  const config = loadAgentRelayConfig(projectRoot);
+  const result = new Map<string, ResolvedShadowConfig>();
+
+  if (!config?.shadows?.pairs) {
+    return result;
+  }
+
+  for (const primaryName of Object.keys(config.shadows.pairs)) {
+    const resolved = getShadowForAgent(projectRoot, primaryName);
+    if (resolved) {
+      result.set(primaryName, resolved);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Check if shadow config exists
+ */
+export function hasShadowConfig(projectRoot: string): boolean {
+  const config = loadAgentRelayConfig(projectRoot);
+  return !!(config?.shadows?.pairs && Object.keys(config.shadows.pairs).length > 0);
+}
+
+/**
+ * Get the config file path that would be used
+ */
+export function getConfigPath(projectRoot: string): string | null {
+  const configPaths = getConfigPaths(projectRoot);
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}

package/packages/config/src/teams-config.ts

@@ -0,0 +1,135 @@
+/**
+ * Teams Configuration
+ * Handles loading and parsing teams.json for auto-spawn and agent validation.
+ *
+ * teams.json can be placed in:
+ * - Project root: ./teams.json
+ * - Agent-relay dir: ./.agent-relay/teams.json
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** Agent definition in teams.json */
+export interface TeamAgentConfig {
+  /** Agent name (used for spawn and validation) */
+  name: string;
+  /** CLI command to use (e.g., 'claude', 'claude:opus', 'codex') */
+  cli: string;
+  /** Agent role (e.g., 'coordinator', 'developer', 'reviewer') */
+  role?: string;
+  /** Initial task/prompt to inject when spawning */
+  task?: string;
+}
+
+/** teams.json file structure */
+export interface TeamsConfig {
+  /** Team name (for identification) */
+  team: string;
+  /** Agents defined in this team */
+  agents: TeamAgentConfig[];
+  /** If true, agent-relay up will auto-spawn all agents */
+  autoSpawn?: boolean;
+}
+
+/**
+ * Possible locations for teams.json (in order of precedence)
+ */
+function getTeamsConfigPaths(projectRoot: string): string[] {
+  return [
+    path.join(projectRoot, '.agent-relay', 'teams.json'),
+    path.join(projectRoot, 'teams.json'),
+  ];
+}
+
+/**
+ * Load teams.json from project root or .agent-relay directory
+ * Returns null if no config found
+ */
+export function loadTeamsConfig(projectRoot: string): TeamsConfig | null {
+  const configPaths = getTeamsConfigPaths(projectRoot);
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content) as TeamsConfig;
+
+        // Validate required fields
+        if (!config.team || typeof config.team !== 'string') {
+          console.error(`[teams-config] Invalid teams.json at ${configPath}: missing or invalid 'team' field`);
+          continue;
+        }
+
+        if (!Array.isArray(config.agents)) {
+          console.error(`[teams-config] Invalid teams.json at ${configPath}: 'agents' must be an array`);
+          continue;
+        }
+
+        // Validate agents
+        const validAgents: TeamAgentConfig[] = [];
+        for (const agent of config.agents) {
+          if (!agent.name || typeof agent.name !== 'string') {
+            console.warn(`[teams-config] Skipping agent with missing name in ${configPath}`);
+            continue;
+          }
+          if (!agent.cli || typeof agent.cli !== 'string') {
+            console.warn(`[teams-config] Agent '${agent.name}' missing 'cli' field, defaulting to 'claude'`);
+            agent.cli = 'claude';
+          }
+          validAgents.push(agent);
+        }
+
+        console.log(`[teams-config] Loaded team '${config.team}' from ${configPath} (${validAgents.length} agents)`);
+
+        return {
+          team: config.team,
+          agents: validAgents,
+          autoSpawn: config.autoSpawn ?? false,
+        };
+      } catch (err) {
+        console.error(`[teams-config] Failed to parse ${configPath}:`, err);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if an agent name is valid according to teams.json
+ * Returns true if no teams.json exists (permissive mode)
+ */
+export function isValidAgentName(projectRoot: string, agentName: string): boolean {
+  const config = loadTeamsConfig(projectRoot);
+
+  // No config = permissive mode
+  if (!config) {
+    return true;
+  }
+
+  return config.agents.some(a => a.name === agentName);
+}
+
+/**
+ * Get agent config by name from teams.json
+ */
+export function getAgentConfig(projectRoot: string, agentName: string): TeamAgentConfig | null {
+  const config = loadTeamsConfig(projectRoot);
+  if (!config) return null;
+
+  return config.agents.find(a => a.name === agentName) ?? null;
+}
+
+/**
+ * Get teams.json path that would be used (for error messages)
+ */
+export function getTeamsConfigPath(projectRoot: string): string | null {
+  const configPaths = getTeamsConfigPaths(projectRoot);
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}