supipowers 2.0.1 → 2.1.0

package/src/mcp/activation.ts

@@ -1,77 +0,0 @@
-import type { ServerConfig } from "./types.js";
-
-/** Extract $tags from user input, matching against registered server names */
-export function parseTags(text: string, registeredNames: Set<string>): string[] {
-  const tags: string[] = [];
-  // Sort names by length (longest first) to match "figma-plugin" before "figma"
-  const sorted = [...registeredNames].sort((a, b) => b.length - a.length);
-
-  for (const name of sorted) {
-    // Build regex: word-boundary-aware, case-insensitive
-    const pattern = new RegExp(`(?:^|[\\s(])\\$${escapeRegex(name)}(?=$|[\\s).,;:!?])`, "gi");
-    if (pattern.test(text)) {
-      tags.push(name);
-    }
-  }
-
-  return tags;
-}
-
-function escapeRegex(s: string): string {
-  return s.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-}
-
-/** Check if a trigger/antiTrigger matches the message */
-function matchesAny(words: string[], message: string): boolean {
-  const lower = message.toLowerCase();
-  return words.some((w) => {
-    const pattern = new RegExp(`\\b${escapeRegex(w.toLowerCase())}\\b`);
-    return pattern.test(lower);
-  });
-}
-
-/** Determine if a server should be active for this turn */
-export function shouldActivate(
-  config: ServerConfig,
-  message: string,
-  isTagged: boolean,
-): boolean {
-  if (!config.enabled) return false;
-
-  // Tag overrides everything (if taggable)
-  if (isTagged && config.taggable) return true;
-
-  switch (config.activation) {
-    case "always":
-      return true;
-    case "contextual": {
-      const triggerMatch = config.triggers.length > 0 && matchesAny(config.triggers, message);
-      if (!triggerMatch) return false;
-      // AntiTrigger wins
-      const antiMatch = config.antiTriggers.length > 0 && matchesAny(config.antiTriggers, message);
-      return !antiMatch;
-    }
-    case "disabled":
-      return false;
-    default:
-      return false;
-  }
-}
-
-/** Compute which servers should be active for a given message */
-export function computeActiveServers(
-  servers: Record<string, ServerConfig>,
-  message: string,
-  taggedNames: string[],
-): string[] {
-  const tagSet = new Set(taggedNames);
-  const active: string[] = [];
-
-  for (const [name, config] of Object.entries(servers)) {
-    if (shouldActivate(config, message, tagSet.has(name))) {
-      active.push(name);
-    }
-  }
-
-  return active;
-}

package/src/mcp/config.ts

@@ -1,223 +0,0 @@
-// src/mcp/config.ts
-import * as fs from "node:fs";
-import { homedir } from "node:os";
-import * as path from "node:path";
-import type { PlatformPaths } from "../platform/types.js";
-import type { McpRegistry, ServerConfig, HostMcpServer } from "./types.js";
-import { createEmptyRegistry, isValidServerName } from "./types.js";
-
-function getMcpConfigPath(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, ".mcp.json");
-}
-
-function getGlobalMcpConfigPath(paths: PlatformPaths): string {
-  return paths.global(".mcp.json");
-}
-
-function readJsonSafe(filePath: string): Record<string, unknown> | null {
-  try {
-    if (!fs.existsSync(filePath)) return null;
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-export function loadMcpRegistry(paths: PlatformPaths, cwd: string): McpRegistry {
-  const globalData = readJsonSafe(getGlobalMcpConfigPath(paths)) as McpRegistry | null;
-  const projectData = readJsonSafe(getMcpConfigPath(paths, cwd)) as McpRegistry | null;
-
-  const merged: McpRegistry = createEmptyRegistry();
-
-  // Global servers first
-  if (globalData?.servers) {
-    for (const [name, config] of Object.entries(globalData.servers)) {
-      merged.servers[name] = applyDefaults(config);
-    }
-  }
-
-  // Project servers override global
-  if (projectData?.servers) {
-    for (const [name, config] of Object.entries(projectData.servers)) {
-      merged.servers[name] = applyDefaults(config);
-    }
-  }
-
-  return merged;
-}
-
-function applyDefaults(partial: Partial<ServerConfig>): ServerConfig {
-  return {
-    transport: "http",
-    activation: "contextual",
-    taggable: true,
-    triggers: [],
-    antiTriggers: [],
-    enabled: true,
-    authPending: false,
-    addedAt: new Date().toISOString(),
-    ...partial,
-  } as ServerConfig;
-}
-
-export function saveMcpRegistry(paths: PlatformPaths, cwd: string, registry: McpRegistry): void {
-  const configPath = getMcpConfigPath(paths, cwd);
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(registry, null, 2) + "\n");
-}
-
-/** Load project-only registry (not merged with global) for save operations */
-function loadProjectRegistry(paths: PlatformPaths, cwd: string): McpRegistry {
-  const data = readJsonSafe(getMcpConfigPath(paths, cwd)) as McpRegistry | null;
-  return data ?? createEmptyRegistry();
-}
-
-export function addServer(
-  paths: PlatformPaths,
-  cwd: string,
-  name: string,
-  config: Partial<ServerConfig>,
-): { ok: boolean; reason?: string } {
-  const validation = isValidServerName(name);
-  if (!validation.valid) return { ok: false, reason: validation.reason };
-
-  const registry = loadProjectRegistry(paths, cwd);
-  registry.servers[name] = applyDefaults({ ...config, addedAt: new Date().toISOString() });
-  saveMcpRegistry(paths, cwd, registry);
-  return { ok: true };
-}
-
-export function removeServer(paths: PlatformPaths, cwd: string, name: string): void {
-  const registry = loadProjectRegistry(paths, cwd);
-  delete registry.servers[name];
-  saveMcpRegistry(paths, cwd, registry);
-}
-
-export function updateServer(
-  paths: PlatformPaths,
-  cwd: string,
-  name: string,
-  updates: Partial<ServerConfig>,
-): { ok: boolean; reason?: string } {
-  const registry = loadProjectRegistry(paths, cwd);
-  if (!registry.servers[name]) return { ok: false, reason: `Server "${name}" not found` };
-  registry.servers[name] = { ...registry.servers[name], ...updates };
-  saveMcpRegistry(paths, cwd, registry);
-  return { ok: true };
-}
-
-export function getServerConfig(
-  paths: PlatformPaths,
-  cwd: string,
-  name: string,
-): ServerConfig | undefined {
-  const registry = loadMcpRegistry(paths, cwd);
-  return registry.servers[name];
-}
-
-// ── Lockfile ──────────────────────────────────────────────────
-
-const LOCK_TIMEOUT_MS = 5000;
-
-export function acquireLock(paths: PlatformPaths, cwd: string): { acquired: boolean; release: () => void } {
-  const lockPath = paths.project(cwd, ".mcp.lock");
-  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-
-  // Check for stale lock
-  if (fs.existsSync(lockPath)) {
-    try {
-      const data = JSON.parse(fs.readFileSync(lockPath, "utf-8"));
-      const age = Date.now() - data.timestamp;
-      if (age < LOCK_TIMEOUT_MS) {
-        return { acquired: false, release: () => {} };
-      }
-    } catch { /* corrupt lock, overwrite */ }
-  }
-
-  fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
-
-  return {
-    acquired: true,
-    release: () => {
-      try { fs.unlinkSync(lockPath); } catch { /* already cleaned */ }
-    },
-  };
-}
-
-
-// ── Host Config Discovery ─────────────────────────────────────
-
-interface HostMcpRaw {
-  mcpServers?: Record<string, {
-    type?: "stdio" | "http" | "sse";
-    command?: string;
-    args?: string[];
-    url?: string;
-    headers?: Record<string, string>;
-    env?: Record<string, string>;
-    enabled?: boolean;
-    auth?: unknown;
-    oauth?: unknown;
-  }>;
-}
-
-/**
- * Discover MCP servers from host config files:
- *   - User-level OMP: paths.agent("mcp.json") → ~/.omp/agent/mcp.json
- *   - Project-level OMP: <cwd>/<dotDir>/mcp.json → <cwd>/.omp/mcp.json
- *   - Claude Code:          ~/.claude.json
- *
- * All use the same { mcpServers: Record<string, ...> } shape.
- */
-export function discoverHostMcpServers(
-  paths: PlatformPaths,
-  cwd: string,
-  homeDir: string = homedir(),
-): HostMcpServer[] {
-  const dot = paths.dotDir;
-
-  // OMP agent-level (user) config: ~/.omp/agent/mcp.json
-  const userPath = paths.agent("mcp.json");
-  // OMP project-level config: <cwd>/.omp/mcp.json
-  const projectPath = path.join(cwd, dot, "mcp.json");
-  // Claude Code user config: ~/.claude.json
-  const claudeCodePath = path.join(homeDir, ".claude.json");
-
-  const sources: Array<{ scope: HostMcpServer["scope"]; filePath: string }> = [
-    { scope: "user", filePath: userPath },
-    { scope: "project", filePath: projectPath },
-    { scope: "claude-code", filePath: claudeCodePath },
-  ];
-
-  const discovered: HostMcpServer[] = [];
-
-  for (const { scope, filePath } of sources) {
-    const data = readJsonSafe(filePath) as HostMcpRaw | null;
-    if (!data?.mcpServers) continue;
-
-    for (const [name, raw] of Object.entries(data.mcpServers)) {
-      // Skip explicitly disabled servers
-      if (raw.enabled === false) continue;
-
-      const effectiveType = raw.type ?? "stdio";
-      let transport: HostMcpServer["transport"] = "stdio";
-      if (effectiveType === "http") transport = "http";
-      else if (effectiveType === "sse") transport = "sse";
-
-      discovered.push({
-        name,
-        scope,
-        transport,
-        url: raw.url,
-        command: raw.command,
-        args: raw.args,
-        env: raw.env,
-        headers: raw.headers,
-        enabled: raw.enabled,
-        hasAuth: raw.auth !== undefined || raw.oauth !== undefined,
-      });
-    }
-  }
-
-  return discovered;
-}

package/src/mcp/docs.ts

@@ -1,154 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { McpTool, ServerConfig } from "./types.js";
-
-// ── README Generation ────────────────────────────────────────
-
-export function generateReadme(name: string, config: ServerConfig, tools: McpTool[]): string {
-  const lines: string[] = [];
-
-  lines.push(`# ${name} (MCP Server)`);
-  lines.push("");
-  if (config.url) lines.push(`**URL:** ${config.url}`);
-  if (config.command) lines.push(`**Command:** ${config.command} ${(config.args ?? []).join(" ")}`);
-  lines.push(`**Transport:** ${config.transport.toUpperCase()} | **Session:** @supi-${name}`);
-  if (config.auth) lines.push(`**Auth:** ${config.auth.type}${config.auth.profile ? ` (profile: ${config.auth.profile})` : ""}`);
-  lines.push("");
-
-  if (config.triggers?.length > 0) {
-    lines.push("## When to Use");
-    for (const t of config.triggers) lines.push(`- ${t}`);
-    lines.push("");
-  }
-
-  lines.push("## Tools");
-  lines.push("");
-  for (const tool of tools) {
-    lines.push(`### ${tool.name}`);
-    if (tool.description) lines.push(tool.description);
-    if (tool.inputSchema) {
-      const props = (tool.inputSchema as any).properties;
-      if (props) {
-        lines.push("**Parameters:**");
-        for (const [pName, pDef] of Object.entries(props)) {
-          const def = pDef as any;
-          lines.push(`- \`${pName}\` (${def.type ?? "any"}) — ${def.description ?? ""}`);
-        }
-      }
-    }
-    lines.push("");
-    lines.push("**Example:**");
-    lines.push("```bash");
-    lines.push(`mcpc --json @supi-${name} tools-call ${tool.name}`);
-    lines.push("```");
-    lines.push("");
-  }
-
-  lines.push("---");
-  lines.push(`*Generated by supipowers. Refresh with /supi:mcp refresh ${name}*`);
-
-  return lines.join("\n");
-}
-
-export function writeReadme(basePath: string, name: string, content: string): void {
-  const dir = path.join(basePath, "mcpc", name);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, "README.md"), content);
-}
-
-export function writeToolsCache(basePath: string, name: string, tools: McpTool[]): void {
-  const dir = path.join(basePath, "mcpc", name);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, "tools.json"), JSON.stringify(tools, null, 2));
-}
-
-// ── Skill Generation ─────────────────────────────────────────
-
-export function generateSkill(servers: Record<string, { tools: McpTool[] }>): string {
-  const names = Object.keys(servers);
-  const triggerList = names.map((n) => `$${n}`).join(", ");
-
-  const lines: string[] = [];
-  lines.push("---");
-  lines.push("name: supi:mcpc");
-  lines.push(`description: Use mcpc CLI to interact with MCP servers managed by supipowers. Triggers on: ${triggerList} or any mcpc tool invocation.`);
-  lines.push("allowed-tools: Bash(mcpc:*)");
-  lines.push("---");
-  lines.push("");
-  lines.push("# mcpc: MCP tools via supipowers");
-  lines.push("");
-  lines.push("Use the `mcpc_<name>` gateway tools to interact with MCP servers.");
-  lines.push("Each server has a dedicated tool registered in your Available Tools.");
-  lines.push("");
-  lines.push("## Quick Reference");
-  lines.push("");
-  lines.push("The gateway tools accept `tool` (MCP tool name) and `args` (key-value object).");
-  lines.push("Under the hood, they run: `mcpc --json @supi-<name> tools-call <tool> key:=value`");
-  lines.push("");
-  lines.push("## Available Servers");
-  lines.push("");
-
-  for (const [name, { tools }] of Object.entries(servers)) {
-    lines.push(`### ${name} (@supi-${name})`);
-    lines.push(`Tools: ${tools.map((t) => t.name).join(", ")}`);
-    lines.push("");
-  }
-
-  return lines.join("\n");
-}
-
-export function writeSkill(basePath: string, content: string): void {
-  const dir = path.join(basePath, "skills", "mcpc");
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, "SKILL.md"), content);
-}
-
-// ── AGENTS.md ────────────────────────────────────────────────
-
-const MARKER_START = "<!-- supipowers:mcpc:start -->";
-const MARKER_END = "<!-- supipowers:mcpc:end -->";
-
-function buildManagedSection(servers: Record<string, { description: string }>): string {
-  const entries = Object.entries(servers);
-  if (entries.length === 0) return "";
-
-  const lines: string[] = [];
-  lines.push(MARKER_START);
-  lines.push("## MCP Servers (managed by supipowers)");
-  lines.push("");
-  lines.push("The following MCP servers are available via `$tag` or the `mcpc_<name>` tool:");
-  lines.push("");
-  for (const [name, { description }] of entries) {
-    lines.push(`- **$${name}** — ${description}. Details: .omp/supipowers/mcpc/${name}/README.md`);
-  }
-  lines.push("");
-  lines.push("Use `/supi:mcp` to manage servers. Invoke the `supi:mcpc` skill for usage patterns.");
-  lines.push(MARKER_END);
-  return lines.join("\n");
-}
-
-export function updateAgentsMd(cwd: string, servers: Record<string, { description: string }>): void {
-  const agentsPath = path.join(cwd, "AGENTS.md");
-  const section = buildManagedSection(servers);
-
-  if (!fs.existsSync(agentsPath)) {
-    if (section) fs.writeFileSync(agentsPath, section + "\n");
-    return;
-  }
-
-  let content = fs.readFileSync(agentsPath, "utf-8");
-  const startIdx = content.indexOf(MARKER_START);
-  const endIdx = content.indexOf(MARKER_END);
-
-  if (startIdx !== -1 && endIdx !== -1) {
-    // Replace existing section
-    const before = content.slice(0, startIdx);
-    const after = content.slice(endIdx + MARKER_END.length);
-    content = section ? before + section + after : before.trimEnd() + after;
-  } else if (section) {
-    // Append
-    content = content.trimEnd() + "\n\n" + section + "\n";
-  }
-
-  fs.writeFileSync(agentsPath, content);
-}

package/src/mcp/gateway.ts

@@ -1,103 +0,0 @@
-// src/mcp/gateway.ts
-import type { ServerConfig, McpTool } from "./types.js";
-import type { McpcClient } from "./mcpc.js";
-
-const SNIPPET_TOOL_LIMIT = 10;
-
-export function buildPromptSnippet(name: string, tools: McpTool[]): string {
-  const toolNames = tools.slice(0, SNIPPET_TOOL_LIMIT).map((t) => t.name);
-  const suffix = tools.length > SNIPPET_TOOL_LIMIT
-    ? ` (${tools.length} tools, see README for full list)`
-    : ` (${tools.length} tools)`;
-  return `mcpc_${name} — ${toolNames.join(", ")}${suffix}`;
-}
-
-export function buildPromptGuidelines(config: ServerConfig): string[] {
-  const guidelines: string[] = [];
-  if (config.triggers.length > 0) {
-    guidelines.push(`Use when the context involves: ${config.triggers.join(", ")}`);
-  }
-  if (config.antiTriggers.length > 0) {
-    guidelines.push(`Do NOT use for: ${config.antiTriggers.join(", ")}`);
-  }
-  return guidelines;
-}
-
-export interface GatewayToolDef {
-  name: string;
-  label: string;
-  description: string;
-  promptSnippet: string;
-  promptGuidelines: string[];
-  parameters: any; // TypeBox schema — built at registration time
-  executeFn: (toolName: string, args?: Record<string, unknown>) => Promise<any>;
-}
-
-export function buildGatewayToolDef(
-  name: string,
-  config: ServerConfig,
-  tools: McpTool[],
-): GatewayToolDef {
-  const descriptions = tools.slice(0, 5).map((t) => t.description).filter(Boolean);
-  const summary = descriptions.join(". ").slice(0, 200);
-
-  return {
-    name: `mcpc_${name}`,
-    label: `${name} (via mcpc)`,
-    description: summary || `MCP server: ${name}`,
-    promptSnippet: buildPromptSnippet(name, tools),
-    promptGuidelines: buildPromptGuidelines(config),
-    parameters: {}, // Placeholder — actual TypeBox schema built at registration time
-    executeFn: async () => {}, // Placeholder — wired at registration time
-  };
-}
-
-/**
- * Build the mcpc args serialization and execute a tool call via mcpc.
- * Returns content blocks for the agent.
- */
-export async function executeGatewayCall(
-  client: McpcClient,
-  sessionName: string,
-  toolName: string,
-  args?: Record<string, unknown>,
-): Promise<{ content: Array<{ type: string; text: string }>; details: Record<string, any> }> {
-  let result = await client.toolsCall(sessionName, toolName, args);
-
-  // Session crash (exit code 3) — restart and retry once
-  if (result.code === 3) {
-    const restartResult = await client.restart(sessionName);
-    if (restartResult.code !== 0) {
-      throw new Error(`Session @supi-${sessionName} crashed and couldn't recover. Run /supi:mcp login ${sessionName} or check network.`);
-    }
-    result = await client.toolsCall(sessionName, toolName, args);
-    if (result.code !== 0) {
-      throw new Error(result.error || `mcpc call failed after restart (code ${result.code})`);
-    }
-  }
-
-  // Stale tool cache (exit code 2) — hint to refresh
-  if (result.code === 2) {
-    const refreshed = await client.toolsList(sessionName);
-    const toolNames = refreshed.tools.map((t) => t.name).join(", ");
-    throw new Error(`Tool "${toolName}" not found. Server tools have been refreshed. Available: [${toolNames}]. Please retry.`);
-  }
-
-  if (result.code !== 0) {
-    throw new Error(result.error || `mcpc exited with code ${result.code}`);
-  }
-
-  // mcpc --json returns { content: [...] } for tool calls
-  if (result.data?.content) {
-    return {
-      content: result.data.content,
-      details: { serverSession: `@supi-${sessionName}`, toolName },
-    };
-  }
-
-  // Fallback: wrap raw output
-  return {
-    content: [{ type: "text", text: typeof result.data === "string" ? result.data : JSON.stringify(result.data) }],
-    details: { serverSession: `@supi-${sessionName}`, toolName },
-  };
-}

package/src/mcp/lifecycle.ts

@@ -1,79 +0,0 @@
-// src/mcp/lifecycle.ts
-import type { McpRegistry, ServerState } from "./types.js";
-import type { McpcClient } from "./mcpc.js";
-
-const RETRY_DELAY_MS = 2000;
-
-export async function initializeMcpServers(
-  registry: McpRegistry,
-  client: McpcClient,
-): Promise<Record<string, ServerState>> {
-  const states: Record<string, ServerState> = {};
-
-  for (const [name, config] of Object.entries(registry.servers)) {
-    if (!config.enabled) {
-      states[name] = { config, status: "disconnected" };
-      continue;
-    }
-
-    const target = config.url ?? config.command ?? "";
-
-    // Build auth header for bearer tokens
-    let authHeader: string | undefined;
-    if (config.auth?.type === "bearer" && config.auth.envVar) {
-      const token = process.env[config.auth.envVar];
-      if (token) authHeader = `Authorization: Bearer ${token}`;
-    }
-
-    let connectResult = await client.connect(target, name, authHeader);
-
-    // Auth error
-    if (connectResult.code === 4) {
-      states[name] = { config: { ...config, authPending: true }, status: "auth-pending" };
-      continue;
-    }
-
-    // Network error — retry once
-    if (connectResult.code === 3) {
-      await delay(RETRY_DELAY_MS);
-      connectResult = await client.connect(target, name, authHeader);
-      if (connectResult.code !== 0) {
-        states[name] = { config, status: "offline" };
-        continue;
-      }
-    }
-
-    if (connectResult.code !== 0) {
-      states[name] = { config, status: "offline" };
-      continue;
-    }
-
-    // Fetch tool catalog
-    const toolsResult = await client.toolsList(name);
-    const catalog = {
-      serverName: name,
-      tools: toolsResult.tools,
-      fetchedAt: new Date().toISOString(),
-    };
-
-    states[name] = { config, status: "connected", catalog };
-  }
-
-  return states;
-}
-
-export async function shutdownMcpServers(
-  sessionNames: string[],
-  client: McpcClient,
-  closeOnExit: boolean,
-): Promise<void> {
-  if (!closeOnExit) return;
-
-  await Promise.allSettled(
-    sessionNames.map((name) => client.close(name)),
-  );
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}