@openparachute/agent 0.1.2 → 0.2.2

package/.claude/skills/migrate-from-openclaw/scripts/discover-openclaw.ts

@@ -1,734 +0,0 @@
-/**
- * Discover an existing OpenClaw installation and emit a structured summary.
- *
- * Usage: pnpm exec tsx .claude/skills/migrate-from-openclaw/scripts/discover-openclaw.ts [--state-dir <path>]
- *
- * Checks (in order): --state-dir arg, $OPENCLAW_STATE_DIR, ~/.openclaw, ~/.clawdbot
- * Parses openclaw.json (JSON5-tolerant), scans workspace for identity/memory files,
- * checks cron jobs, MCP servers, and channel credentials.
- *
- * Emits a status block on stdout:
- *   === NANOCLAW MIGRATE: DISCOVERY ===
- *   ...
- *   === END ===
- */
-
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-// ---------------------------------------------------------------------------
-// JSON5-tolerant parser (no dependency)
-// ---------------------------------------------------------------------------
-
-function parseJson5(text: string): unknown {
-  // Strip single-line comments (// ...) that aren't inside strings
-  let cleaned = text.replace(
-    /("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g,
-    (match, str) => (str ? str : ''),
-  );
-  // Strip block comments (/* ... */)
-  cleaned = cleaned.replace(
-    /("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g,
-    (match, str) => (str ? str : ''),
-  );
-  // Strip trailing commas before } or ]
-  cleaned = cleaned.replace(/,\s*([}\]])/g, '$1');
-  return JSON.parse(cleaned);
-}
-
-// ---------------------------------------------------------------------------
-// Status block emitter (mirrors setup/status.ts convention)
-// ---------------------------------------------------------------------------
-
-function emitStatus(fields: Record<string, string | number | boolean>): void {
-  const lines = ['=== NANOCLAW MIGRATE: DISCOVERY ==='];
-  for (const [key, value] of Object.entries(fields)) {
-    lines.push(`${key}: ${value}`);
-  }
-  lines.push('=== END ===');
-  console.log(lines.join('\n'));
-}
-
-// ---------------------------------------------------------------------------
-// CLI arg parsing
-// ---------------------------------------------------------------------------
-
-function parseArgs(): { stateDir?: string } {
-  const args = process.argv.slice(2);
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--state-dir' && args[i + 1]) {
-      return { stateDir: args[i + 1] };
-    }
-  }
-  return {};
-}
-
-// ---------------------------------------------------------------------------
-// Path resolution
-// ---------------------------------------------------------------------------
-
-function resolveStateDir(explicit?: string): string | null {
-  const home = os.homedir();
-  const candidates: string[] = [];
-
-  if (explicit) {
-    // Expand ~ prefix
-    const expanded = explicit.startsWith('~')
-      ? path.join(home, explicit.slice(1))
-      : explicit;
-    candidates.push(expanded);
-  }
-
-  if (process.env.OPENCLAW_STATE_DIR) {
-    candidates.push(process.env.OPENCLAW_STATE_DIR);
-  }
-
-  candidates.push(path.join(home, '.openclaw'));
-  candidates.push(path.join(home, '.clawdbot'));
-
-  for (const dir of candidates) {
-    if (fs.existsSync(dir) && fs.statSync(dir).isDirectory()) {
-      return dir;
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Config loading
-// ---------------------------------------------------------------------------
-
-function loadConfig(
-  stateDir: string,
-): Record<string, unknown> | null {
-  for (const name of ['openclaw.json', 'clawdbot.json']) {
-    const configPath = path.join(stateDir, name);
-    if (fs.existsSync(configPath)) {
-      try {
-        const raw = fs.readFileSync(configPath, 'utf-8');
-        return parseJson5(raw) as Record<string, unknown>;
-      } catch {
-        // Try next name
-      }
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Channel detection
-// ---------------------------------------------------------------------------
-
-interface ChannelInfo {
-  name: string;
-  hasCreds: boolean;
-}
-
-const SUPPORTED_CHANNELS = new Set([
-  'whatsapp',
-  'telegram',
-  'slack',
-  'discord',
-]);
-
-// Fields that indicate a credential is present for each channel
-const CREDENTIAL_FIELDS: Record<string, string[]> = {
-  telegram: ['botToken'],
-  discord: ['token'],
-  slack: ['botToken', 'appToken'],
-  whatsapp: [], // Auth-state based, no token
-  signal: ['account'],
-  imessage: [],
-  matrix: ['homeserverUrl', 'accessToken'],
-  irc: ['server'],
-  msteams: ['appId'],
-  feishu: ['appId'],
-  googlechat: [],
-  mattermost: ['token', 'url'],
-  zalo: [],
-  bluebubbles: ['url'],
-};
-
-const ALL_KNOWN_CHANNELS = new Set([
-  'whatsapp', 'telegram', 'slack', 'discord', 'signal',
-  'imessage', 'matrix', 'irc', 'msteams', 'feishu',
-  'googlechat', 'mattermost', 'zalo', 'bluebubbles',
-]);
-
-function detectChannels(
-  config: Record<string, unknown>,
-): ChannelInfo[] {
-  // Check both config.channels.* (newer) and top-level config.* (older/legacy)
-  const channelsSections: Record<string, unknown> = {};
-
-  // Source 1: channels.* (standard location)
-  const nested = config.channels as Record<string, unknown> | undefined;
-  if (nested) {
-    for (const [k, v] of Object.entries(nested)) {
-      if (v && typeof v === 'object') channelsSections[k] = v;
-    }
-  }
-
-  // Source 2: top-level keys matching known channel names (legacy format)
-  for (const key of Object.keys(config)) {
-    if (ALL_KNOWN_CHANNELS.has(key) && !channelsSections[key]) {
-      const v = config[key];
-      if (v && typeof v === 'object') channelsSections[key] = v;
-    }
-  }
-
-  const results: ChannelInfo[] = [];
-
-  for (const [name, section] of Object.entries(channelsSections)) {
-    if (!section || typeof section !== 'object') continue;
-    const ch = section as Record<string, unknown>;
-
-    // Check if any credential field is present and non-empty
-    const credFields = CREDENTIAL_FIELDS[name] ?? [];
-    let hasCreds = false;
-
-    for (const field of credFields) {
-      const val = ch[field];
-      if (val && (typeof val === 'string' || typeof val === 'object')) {
-        hasCreds = true;
-        break;
-      }
-    }
-
-    // Also check accounts for multi-account setups
-    if (!hasCreds && ch.accounts && typeof ch.accounts === 'object') {
-      for (const acct of Object.values(
-        ch.accounts as Record<string, unknown>,
-      )) {
-        if (!acct || typeof acct !== 'object') continue;
-        const a = acct as Record<string, unknown>;
-        for (const field of credFields) {
-          if (
-            a[field] &&
-            (typeof a[field] === 'string' || typeof a[field] === 'object')
-          ) {
-            hasCreds = true;
-            break;
-          }
-        }
-        if (hasCreds) break;
-      }
-    }
-
-    // WhatsApp: check for auth state directory instead of token
-    if (name === 'whatsapp' && !hasCreds) {
-      // Will be checked separately via agents directory
-      hasCreds = false;
-    }
-
-    results.push({ name, hasCreds });
-  }
-
-  return results;
-}
-
-// ---------------------------------------------------------------------------
-// Workspace scanning
-// ---------------------------------------------------------------------------
-
-const WORKSPACE_FILES = [
-  'SOUL.md',
-  'USER.md',
-  'MEMORY.md',
-  'IDENTITY.md',
-  'TOOLS.md',
-  'HEARTBEAT.md',
-  'BOOTSTRAP.md',
-  'AGENTS.md',
-];
-
-function findWorkspace(stateDir: string, config: Record<string, unknown> | null): {
-  dir: string | null;
-  files: string[];
-} {
-  // Check config-specified workspace path first (agent.workspace or agents.defaults.workspace)
-  const configPaths: string[] = [];
-  if (config) {
-    const agentWs = (config.agent as Record<string, unknown> | undefined)?.workspace as string | undefined;
-    if (agentWs) configPaths.push(agentWs.startsWith('~') ? path.join(os.homedir(), agentWs.slice(1)) : agentWs);
-    const defaultsWs = ((config.agents as Record<string, unknown> | undefined)?.defaults as Record<string, unknown> | undefined)?.workspace as string | undefined;
-    if (defaultsWs) configPaths.push(defaultsWs.startsWith('~') ? path.join(os.homedir(), defaultsWs.slice(1)) : defaultsWs);
-  }
-
-  // Check config-specified paths, then default locations
-  const candidates = [
-    ...configPaths,
-    ...['workspace', 'workspace.default'].map((n) => path.join(stateDir, n)),
-  ];
-
-  for (const ws of candidates) {
-    if (fs.existsSync(ws) && fs.statSync(ws).isDirectory()) {
-      const found = WORKSPACE_FILES.filter((f) =>
-        fs.existsSync(path.join(ws, f)),
-      );
-      if (found.length > 0) {
-        return { dir: ws, files: found };
-      }
-    }
-  }
-
-  // Check agent-specific workspaces
-  const agentsDir = path.join(stateDir, 'agents');
-  if (fs.existsSync(agentsDir)) {
-    for (const agentId of fs.readdirSync(agentsDir)) {
-      for (const wsName of ['workspace', 'workspace.default']) {
-        const ws = path.join(agentsDir, agentId, wsName);
-        if (fs.existsSync(ws) && fs.statSync(ws).isDirectory()) {
-          const found = WORKSPACE_FILES.filter((f) =>
-            fs.existsSync(path.join(ws, f)),
-          );
-          if (found.length > 0) {
-            return { dir: ws, files: found };
-          }
-        }
-      }
-    }
-  }
-
-  return { dir: null, files: [] };
-}
-
-// ---------------------------------------------------------------------------
-// Daily memory file detection
-// ---------------------------------------------------------------------------
-
-function countDailyMemoryFiles(workspaceDir: string | null): number {
-  if (!workspaceDir) return 0;
-  const memoryDir = path.join(workspaceDir, 'memory');
-  if (!fs.existsSync(memoryDir) || !fs.statSync(memoryDir).isDirectory()) {
-    return 0;
-  }
-  try {
-    return fs
-      .readdirSync(memoryDir)
-      .filter((f) => f.endsWith('.md'))
-      .length;
-  } catch {
-    return 0;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Skills detection
-// ---------------------------------------------------------------------------
-
-interface SkillInfo {
-  name: string;
-  source: string; // 'workspace' | 'shared' | 'personal' | 'project'
-  path: string;
-}
-
-function detectSkills(
-  stateDir: string,
-  workspaceDir: string | null,
-): SkillInfo[] {
-  const skills: SkillInfo[] = [];
-  const seen = new Set<string>();
-
-  const scanDir = (dir: string, source: string) => {
-    if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return;
-    try {
-      for (const entry of fs.readdirSync(dir)) {
-        const skillDir = path.join(dir, entry);
-        if (!fs.statSync(skillDir).isDirectory()) continue;
-        // A directory is a skill if it contains SKILL.md
-        if (fs.existsSync(path.join(skillDir, 'SKILL.md'))) {
-          if (seen.has(entry)) continue;
-          seen.add(entry);
-          skills.push({ name: entry, source, path: skillDir });
-        }
-      }
-    } catch {
-      // ignore read errors
-    }
-  };
-
-  // 1. Workspace skills
-  if (workspaceDir) {
-    scanDir(path.join(workspaceDir, 'skills'), 'workspace');
-    // 4. Project-level shared skills
-    scanDir(path.join(workspaceDir, '.agents', 'skills'), 'project');
-  }
-
-  // 2. Managed/shared skills
-  scanDir(path.join(stateDir, 'skills'), 'shared');
-
-  // 3. Personal cross-project skills
-  const personalSkills = path.join(os.homedir(), '.agents', 'skills');
-  scanDir(personalSkills, 'personal');
-
-  return skills;
-}
-
-// ---------------------------------------------------------------------------
-// Identity extraction
-// ---------------------------------------------------------------------------
-
-function extractIdentityName(stateDir: string, workspaceDir: string | null): string {
-  if (!workspaceDir) return '';
-
-  const identityPath = path.join(workspaceDir, 'IDENTITY.md');
-  if (!fs.existsSync(identityPath)) return '';
-
-  try {
-    const content = fs.readFileSync(identityPath, 'utf-8');
-    // IDENTITY.md uses key:value format, e.g. "name: Claw"
-    const match = content.match(/^name:\s*(.+)/im);
-    return match ? match[1].trim() : '';
-  } catch {
-    return '';
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Agent detection
-// ---------------------------------------------------------------------------
-
-function detectAgents(stateDir: string): string[] {
-  const agentsDir = path.join(stateDir, 'agents');
-  if (!fs.existsSync(agentsDir)) return [];
-
-  try {
-    return fs
-      .readdirSync(agentsDir)
-      .filter((f) => {
-        const p = path.join(agentsDir, f);
-        return fs.statSync(p).isDirectory() && !f.startsWith('.');
-      });
-  } catch {
-    return [];
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Group detection — from session store and channel config
-// ---------------------------------------------------------------------------
-
-interface GroupInfo {
-  channel: string;
-  id: string; // Platform-specific ID (WhatsApp JID, Telegram chat ID, etc.)
-  name: string;
-  source: 'session' | 'config';
-}
-
-/**
- * Map OpenClaw session key channel:kind:id to NanoClaw JID format.
- * OpenClaw keys: "whatsapp:group:120...@g.us", "telegram:group:-10012345"
- * NanoClaw JIDs: "120...@g.us", "tg:-10012345", "dc:12345", "slack:C12345"
- */
-function toNanoClawJid(channel: string, id: string): string {
-  switch (channel) {
-    case 'whatsapp':
-      return id; // Already in JID format (120...@g.us)
-    case 'telegram':
-      return `tg:${id}`;
-    case 'discord':
-      return `dc:${id}`;
-    case 'slack':
-      return `slack:${id}`;
-    default:
-      return `${channel}:${id}`;
-  }
-}
-
-function detectGroups(
-  stateDir: string,
-  config: Record<string, unknown> | null,
-  agents: string[],
-): GroupInfo[] {
-  const groups: GroupInfo[] = [];
-  const seen = new Set<string>();
-
-  // Source 1: Session store — scan for group session keys
-  for (const agentId of agents) {
-    const sessionsPath = path.join(
-      stateDir,
-      'agents',
-      agentId,
-      'sessions',
-      'sessions.json',
-    );
-    if (!fs.existsSync(sessionsPath)) continue;
-
-    try {
-      const raw = fs.readFileSync(sessionsPath, 'utf-8');
-      const data = JSON.parse(raw) as Record<string, unknown>;
-
-      // Sessions can be stored as an object with session keys, or as
-      // { sessions: { key: entry } } or { entries: [...] }
-      const entries =
-        (data.sessions as Record<string, unknown>) ??
-        (data.entries as Record<string, unknown>) ??
-        data;
-
-      for (const [key, value] of Object.entries(entries)) {
-        // Match session keys like "whatsapp:group:120...@g.us"
-        // or prefixed "agent:main:whatsapp:group:120...@g.us"
-        // Also match DM sessions: "whatsapp:dm:number@s.whatsapp.net"
-        const match = key.match(/(\w+):(group|dm|channel):(.+)$/i);
-        if (!match) continue;
-
-        const [, channel, kind, id] = match;
-        // Skip DM sessions for group detection — they're individual chats
-        if (kind === 'dm') continue;
-        const dedupKey = `${channel}:${id}`;
-        if (seen.has(dedupKey)) continue;
-        seen.add(dedupKey);
-
-        // Try to extract display name from session entry
-        let name = '';
-        if (value && typeof value === 'object') {
-          const entry = value as Record<string, unknown>;
-          name =
-            (entry.displayName as string) ??
-            (entry.label as string) ??
-            (entry.subject as string) ??
-            '';
-        }
-
-        groups.push({
-          channel,
-          id,
-          name: name || id,
-          source: 'session',
-        });
-      }
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Source 2: Channel config — groups explicitly configured
-  if (config) {
-    const channels =
-      (config.channels as Record<string, unknown> | undefined) ?? {};
-    for (const [channelName, channelSection] of Object.entries(channels)) {
-      if (!channelSection || typeof channelSection !== 'object') continue;
-      const ch = channelSection as Record<string, unknown>;
-
-      // WhatsApp/Telegram: channels.<channel>.groups.<groupId>
-      const configGroups = ch.groups as Record<string, unknown> | undefined;
-      if (configGroups) {
-        for (const groupId of Object.keys(configGroups)) {
-          const dedupKey = `${channelName}:${groupId}`;
-          if (seen.has(dedupKey)) continue;
-          seen.add(dedupKey);
-          groups.push({
-            channel: channelName,
-            id: groupId,
-            name: groupId,
-            source: 'config',
-          });
-        }
-      }
-
-      // Discord: channels.discord.guilds.<guildId>
-      if (channelName === 'discord') {
-        const guilds = ch.guilds as Record<string, unknown> | undefined;
-        if (guilds) {
-          for (const guildId of Object.keys(guilds)) {
-            const dedupKey = `discord:${guildId}`;
-            if (seen.has(dedupKey)) continue;
-            seen.add(dedupKey);
-            groups.push({
-              channel: 'discord',
-              id: guildId,
-              name: guildId,
-              source: 'config',
-            });
-          }
-        }
-      }
-    }
-  }
-
-  return groups;
-}
-
-// ---------------------------------------------------------------------------
-// Cron job counting
-// ---------------------------------------------------------------------------
-
-function countCronJobs(stateDir: string): {
-  count: number;
-  summaries: string[];
-} {
-  const jobsPath = path.join(stateDir, 'cron', 'jobs.json');
-  if (!fs.existsSync(jobsPath)) return { count: 0, summaries: [] };
-
-  try {
-    const raw = fs.readFileSync(jobsPath, 'utf-8');
-    const data = JSON.parse(raw) as {
-      jobs?: Array<{ name?: string; enabled?: boolean }>;
-    };
-    const jobs = data.jobs ?? [];
-    const summaries = jobs
-      .filter((j) => j.enabled !== false)
-      .map((j) => j.name || 'unnamed')
-      .slice(0, 10);
-    return { count: jobs.length, summaries };
-  } catch {
-    return { count: 0, summaries: [] };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Config-registered plugins and skills (with API keys)
-// ---------------------------------------------------------------------------
-
-interface ConfigPlugin {
-  name: string;
-  source: 'skills.entries' | 'plugins.entries';
-  hasApiKey: boolean;
-}
-
-function detectConfigPlugins(
-  config: Record<string, unknown>,
-): ConfigPlugin[] {
-  const results: ConfigPlugin[] = [];
-
-  // Check skills.entries (e.g. openai-whisper-api with apiKey)
-  const skills = config.skills as Record<string, unknown> | undefined;
-  const skillEntries = skills?.entries as Record<string, unknown> | undefined;
-  if (skillEntries) {
-    for (const [name, entry] of Object.entries(skillEntries)) {
-      if (!entry || typeof entry !== 'object') continue;
-      const e = entry as Record<string, unknown>;
-      const hasKey = !!(e.apiKey || e.token || e.key);
-      results.push({ name, source: 'skills.entries', hasApiKey: hasKey });
-    }
-  }
-
-  // Check plugins.entries (e.g. brave with config.webSearch.apiKey)
-  const plugins = config.plugins as Record<string, unknown> | undefined;
-  const pluginEntries = plugins?.entries as Record<string, unknown> | undefined;
-  if (pluginEntries) {
-    for (const [name, entry] of Object.entries(pluginEntries)) {
-      if (!entry || typeof entry !== 'object') continue;
-      // Deep-search for apiKey in nested config
-      const hasKey = JSON.stringify(entry).includes('apiKey');
-      results.push({ name, source: 'plugins.entries', hasApiKey: hasKey });
-    }
-  }
-
-  return results;
-}
-
-// ---------------------------------------------------------------------------
-// MCP server detection
-// ---------------------------------------------------------------------------
-
-function detectMcpServers(
-  config: Record<string, unknown>,
-): string[] {
-  const mcp = config.mcp as Record<string, unknown> | undefined;
-  if (!mcp) return [];
-  const servers = mcp.servers as Record<string, unknown> | undefined;
-  if (!servers) return [];
-  return Object.keys(servers);
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-function main(): void {
-  const { stateDir: explicitDir } = parseArgs();
-  const stateDir = resolveStateDir(explicitDir);
-
-  if (!stateDir) {
-    emitStatus({ STATUS: 'not_found' });
-    return;
-  }
-
-  const config = loadConfig(stateDir);
-  const channels = config ? detectChannels(config) : [];
-  const { dir: workspaceDir, files: workspaceFiles } =
-    findWorkspace(stateDir, config);
-  const identityName = extractIdentityName(stateDir, workspaceDir);
-  const agents = detectAgents(stateDir);
-  const groups = detectGroups(stateDir, config, agents);
-  const { count: cronCount, summaries: cronSummaries } =
-    countCronJobs(stateDir);
-  const mcpServers = config ? detectMcpServers(config) : [];
-  const dailyMemoryFiles = countDailyMemoryFiles(workspaceDir);
-  const skills = detectSkills(stateDir, workspaceDir);
-  const configPlugins = config ? detectConfigPlugins(config) : [];
-
-  // Format channels as "name(has_creds)" or "name(no_creds)"
-  const channelList = channels
-    .map((c) => `${c.name}(${c.hasCreds ? 'has_creds' : 'no_creds'})`)
-    .join(',');
-
-  // Separate supported vs unsupported
-  const unsupported = channels
-    .filter((c) => !SUPPORTED_CHANNELS.has(c.name))
-    .map((c) => c.name)
-    .join(',');
-
-  // Format groups as "channel:id(name)" — also include NanoClaw JID mapping
-  const groupList = groups
-    .map(
-      (g) =>
-        `${g.channel}:${g.id}(${g.name})=>${toNanoClawJid(g.channel, g.id)}`,
-    )
-    .join('|');
-
-  // Format skills as "name(source)" list
-  const skillList = skills
-    .map((s) => `${s.name}(${s.source})`)
-    .join(',');
-
-  // Dump raw top-level config keys so Claude can see what exists
-  // beyond what this script specifically detects
-  const configTopKeys = config ? Object.keys(config).sort().join(',') : 'none';
-  const configChannelKeys = config?.channels
-    ? Object.keys(config.channels as Record<string, unknown>).sort().join(',')
-    : 'none';
-
-  // List files/dirs at the state dir root for manual inspection
-  let stateDirContents = 'unknown';
-  try {
-    stateDirContents = fs
-      .readdirSync(stateDir)
-      .filter((f) => !f.startsWith('.'))
-      .sort()
-      .join(',');
-  } catch {
-    // ignore
-  }
-
-  emitStatus({
-    STATUS: 'found',
-    STATE_DIR: stateDir,
-    CONFIG_FOUND: config !== null,
-    CONFIG_TOP_KEYS: configTopKeys,
-    CONFIG_CHANNEL_KEYS: configChannelKeys,
-    STATE_DIR_CONTENTS: stateDirContents,
-    CHANNELS: channelList || 'none',
-    UNSUPPORTED_CHANNELS: unsupported || 'none',
-    WORKSPACE_DIR: workspaceDir || 'not_found',
-    WORKSPACE_FILES: workspaceFiles.join(',') || 'none',
-    IDENTITY_NAME: identityName || 'unknown',
-    AGENT_COUNT: agents.length,
-    AGENT_IDS: agents.join(',') || 'none',
-    GROUPS: groupList || 'none',
-    GROUP_COUNT: groups.length,
-    DAILY_MEMORY_FILES: dailyMemoryFiles,
-    SKILL_COUNT: skills.length,
-    SKILLS: skillList || 'none',
-    CONFIG_PLUGINS: configPlugins.map((p) => `${p.name}(${p.source}${p.hasApiKey ? ',has_key' : ''})`).join(',') || 'none',
-    CONFIG_PLUGIN_COUNT: configPlugins.length,
-    CRON_JOBS: cronCount,
-    CRON_SUMMARIES: cronSummaries.join('|') || 'none',
-    MCP_SERVERS: mcpServers.join(',') || 'none',
-  });
-}
-
-main();