supipowers 2.0.2 → 2.2.0

package/src/mcp/manager-tool.ts

@@ -1,104 +0,0 @@
-interface ManagerParams {
-  action: string;
-  name?: string;
-  url?: string;
-  transport?: string;
-  docsUrl?: string;
-  activation?: string;
-  taggable?: boolean;
-}
-
-interface RouteResult {
-  action: string;
-  error?: string;
-}
-
-const ACTIONS_REQUIRING_NAME = new Set([
-  "add", "remove", "enable", "disable", "login", "logout",
-  "set-activation", "set-taggable", "info",
-]);
-
-export type { ManagerParams };
-
-interface ManagerContent {
-  type: string;
-  text: string;
-}
-
-interface ManagerResult {
-  content: ManagerContent[];
-  error?: boolean;
-}
-
-interface ManagerContext {
-  hasUI: boolean;
-  ui: { confirm?: (title: string, message: string) => Promise<boolean> };
-  cwd: string;
-}
-
-interface ManagerDeps {
-  addServer: Function;
-  removeServer: Function;
-  updateServer: Function;
-}
-
-export async function executeManagerAction(
-  params: ManagerParams,
-  ctx: ManagerContext,
-  _deps: ManagerDeps,
-): Promise<ManagerResult> {
-  const route = routeManagerAction(params);
-  if (route.error) {
-    return { content: [{ type: "text", text: route.error }], error: true };
-  }
-
-  switch (params.action) {
-    case "add": {
-      // Confirmation gate for agent-triggered adds
-      if (ctx.hasUI && ctx.ui.confirm) {
-        const confirmed = await ctx.ui.confirm(
-          "Add MCP Server",
-          `Add "${params.name}" from ${params.url}?`,
-        );
-        if (!confirmed) {
-          return { content: [{ type: "text", text: "User cancelled the add operation." }] };
-        }
-      }
-      // Delegate to addServer
-      return { content: [{ type: "text", text: `Server "${params.name}" add initiated.` }] };
-    }
-    default:
-      return { content: [{ type: "text", text: `Action "${params.action}" executed.` }] };
-  }
-}
-
-export function routeManagerAction(params: ManagerParams): RouteResult {
-  const { action, name } = params;
-
-  if (ACTIONS_REQUIRING_NAME.has(action) && !name) {
-    return { action, error: `Action "${action}" requires a server name` };
-  }
-
-  switch (action) {
-    case "add":
-      if (!params.url) return { action, error: "Action \"add\" requires a url" };
-      return { action };
-    case "set-activation":
-      if (!params.activation) return { action, error: "Action \"set-activation\" requires an activation value" };
-      return { action };
-    case "set-taggable":
-      if (params.taggable === undefined) return { action, error: "Action \"set-taggable\" requires a taggable value" };
-      return { action };
-    case "remove":
-    case "enable":
-    case "disable":
-    case "login":
-    case "logout":
-    case "info":
-    case "list":
-    case "refresh":
-      return { action };
-    default:
-      return { action, error: `Unknown action: ${action}` };
-  }
-}

package/src/mcp/mcpc.ts

@@ -1,113 +0,0 @@
-// src/mcp/mcpc.ts
-import type { McpTool } from "./types.js";
-
-type ExecFn = (cmd: string, args: string[], opts?: any) => Promise<{ stdout: string; stderr: string; code: number }>;
-
-/** Combine stdout + stderr, deduplicating if identical */
-function combineOutput(r: { stdout: string; stderr: string }): string {
-  const out = r.stdout.trim();
-  const err = r.stderr.trim();
-  if (!out) return err;
-  if (!err) return out;
-  if (out === err) return out;
-  return [out, err].join("\n");
-}
-
-export class McpcClient {
-  constructor(private exec: ExecFn) {}
-
-  async checkInstalled(): Promise<{ installed: boolean; version?: string }> {
-    try {
-      const r = await this.exec("mcpc", ["--version"]);
-      if (r.code !== 0) return { installed: false };
-      const match = r.stdout.match(/mcpc\s+([\d.]+)/);
-      return { installed: true, version: match?.[1] };
-    } catch {
-      return { installed: false };
-    }
-  }
-
-  async autoInstall(): Promise<boolean> {
-    try {
-      const r = await this.exec("npm", ["install", "-g", "@apify/mcpc"]);
-      return r.code === 0;
-    } catch {
-      return false;
-    }
-  }
-
-  async connect(target: string, sessionName: string, authHeader?: string): Promise<{ code: number; output: string }> {
-    const args = authHeader
-      ? ["-H", authHeader, target, "connect", `@supi-${sessionName}`]
-      : [target, "connect", `@supi-${sessionName}`];
-    const r = await this.exec("mcpc", args);
-    return { code: r.code, output: combineOutput(r) };
-  }
-
-  async close(sessionName: string): Promise<{ code: number; output: string }> {
-    const r = await this.exec("mcpc", [`@supi-${sessionName}`, "close"]);
-    return { code: r.code, output: combineOutput(r) };
-  }
-
-  async restart(sessionName: string): Promise<{ code: number; output: string }> {
-    const r = await this.exec("mcpc", [`@supi-${sessionName}`, "restart"]);
-    return { code: r.code, output: combineOutput(r) };
-  }
-
-  async toolsList(sessionName: string): Promise<{ code: number; tools: McpTool[] }> {
-    const r = await this.exec("mcpc", ["--json", `@supi-${sessionName}`, "tools-list"]);
-    if (r.code !== 0) return { code: r.code, tools: [] };
-    try {
-      const tools = JSON.parse(r.stdout) as McpTool[];
-      return { code: 0, tools };
-    } catch {
-      return { code: r.code, tools: [] };
-    }
-  }
-
-  async toolsCall(
-    sessionName: string,
-    toolName: string,
-    args?: Record<string, unknown>,
-  ): Promise<{ code: number; data?: any; error?: string }> {
-    const cmdArgs = ["--json", `@supi-${sessionName}`, "tools-call", toolName];
-    if (args) {
-      cmdArgs.push(...this.serializeArgs(args));
-    }
-    const r = await this.exec("mcpc", cmdArgs);
-    if (r.code !== 0) return { code: r.code, error: r.stderr || r.stdout };
-    try {
-      return { code: 0, data: JSON.parse(r.stdout) };
-    } catch {
-      return { code: 0, data: r.stdout };
-    }
-  }
-
-  async login(target: string): Promise<{ code: number; output: string }> {
-    // OAuth flows can take minutes (user approving in browser)
-    const r = await this.exec("mcpc", [target, "login"], { timeout: 120000 });
-    return { code: r.code, output: combineOutput(r) };
-  }
-
-  async logout(target: string): Promise<{ code: number; output: string }> {
-    const r = await this.exec("mcpc", [target, "logout"]);
-    return { code: r.code, output: combineOutput(r) };
-  }
-
-  async listSessions(): Promise<{ code: number; output: string }> {
-    const r = await this.exec("mcpc", ["--json"]);
-    return { code: r.code, output: r.stdout };
-  }
-
-  serializeArgs(args: Record<string, unknown>): string[] {
-    const result: string[] = [];
-    for (const [key, value] of Object.entries(args)) {
-      if (typeof value === "string") {
-        result.push(`${key}:="${value}"`);
-      } else {
-        result.push(`${key}:=${JSON.stringify(value)}`);
-      }
-    }
-    return result;
-  }
-}

package/src/mcp/registry.ts

@@ -1,98 +0,0 @@
-// src/mcp/registry.ts — MCP server registry lookup via registry.modelcontextprotocol.io
-
-type ExecFn = (cmd: string, args: string[], opts?: any) => Promise<{ stdout: string; stderr: string; code: number }>;
-
-export interface RegistryServer {
-  name: string;
-  title: string;
-  description: string;
-  url: string;
-  transport: "http" | "stdio";
-  authRequired: boolean;
-  repoUrl?: string;
-  docsUrl?: string;
-}
-
-interface RegistryRemote {
-  type: string;
-  url: string;
-  headers?: Array<{ name: string; isRequired?: boolean }>;
-}
-
-interface RegistryEntry {
-  server: {
-    name: string;
-    title?: string;
-    description?: string;
-    repository?: { url?: string };
-    websiteUrl?: string;
-    remotes?: RegistryRemote[];
-  };
-}
-
-const REGISTRY_BASE = "https://registry.modelcontextprotocol.io";
-
-/**
- * Look up MCP servers by name from the official MCP registry.
- * Uses curl via exec — no web tools or Python needed.
- */
-export async function lookupMcpServer(
-  exec: ExecFn,
-  query: string,
-): Promise<RegistryServer[]> {
-  const url = `${REGISTRY_BASE}/v0/servers?search=${encodeURIComponent(query)}&version=latest&limit=10`;
-
-  const result = await exec("curl", ["-sf", "--max-time", "10", url]);
-  if (result.code !== 0) return [];
-
-  try {
-    const data = JSON.parse(result.stdout);
-    const entries: RegistryEntry[] = data.servers ?? data ?? [];
-    return entries
-      .filter((e) => e.server?.remotes?.length)
-      .map((e) => parseRegistryEntry(e));
-  } catch {
-    return [];
-  }
-}
-
-function parseRegistryEntry(entry: RegistryEntry): RegistryServer {
-  const s = entry.server;
-  const remote = s.remotes![0];
-  const transport = remote.type === "stdio" ? "stdio" as const : "http" as const;
-  const authRequired = remote.headers?.some((h) => h.isRequired) ?? false;
-
-  return {
-    name: s.name,
-    title: s.title ?? s.name,
-    description: s.description ?? "",
-    url: remote.url,
-    transport,
-    authRequired,
-    repoUrl: s.repository?.url,
-    docsUrl: s.websiteUrl ?? s.repository?.url,
-  };
-}
-
-/**
- * Find the best match for a given name from registry results.
- * Prefers exact name matches, then title matches, then substring.
- */
-export function pickBestMatch(results: RegistryServer[], query: string): RegistryServer | undefined {
-  const q = query.toLowerCase();
-
-  // Exact name segment match (e.g., "figma" matches "com.figma.mcp/mcp")
-  const exact = results.find((r) =>
-    r.name.toLowerCase().split(/[./]/).some((seg) => seg === q)
-  );
-  if (exact) return exact;
-
-  // Title contains query
-  const titleMatch = results.find((r) =>
-    r.title.toLowerCase().includes(q)
-  );
-  if (titleMatch) return titleMatch;
-
-  // Any name contains query
-  return results.find((r) => r.name.toLowerCase().includes(q));
-}

package/src/mcp/triggers.ts

@@ -1,62 +0,0 @@
-import type { McpTool } from "./types.js";
-
-const GENERIC_WORDS = new Set([
-  "get", "set", "list", "create", "update", "delete", "read", "write",
-  "find", "search", "fetch", "add", "remove", "the", "a", "an", "of",
-  "from", "to", "in", "on", "is", "for", "and", "or", "with", "by",
-  "all", "new", "this", "that", "it", "be", "are", "was", "has", "have",
-  "will", "can", "do", "does", "not", "no", "if", "use", "using",
-]);
-
-const MAX_TRIGGERS = 10;
-
-/** Split camelCase or snake_case into words */
-function tokenize(name: string): string[] {
-  return name
-    .replace(/([a-z])([A-Z])/g, "$1_$2") // camelCase → snake
-    .toLowerCase()
-    .split(/[_\-\s]+/)
-    .filter((w) => w.length > 2); // skip tiny words
-}
-
-/** Extract keywords from description (simple stop-word filter) */
-function extractKeywords(text: string): string[] {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, " ")
-    .split(/\s+/)
-    .filter((w) => w.length > 2 && !GENERIC_WORDS.has(w));
-}
-
-export function generateTriggers(serverName: string, tools: McpTool[]): string[] {
-  const seen = new Set<string>();
-  const result: string[] = [];
-
-  // Server name always first
-  result.push(serverName);
-  seen.add(serverName);
-
-  for (const tool of tools) {
-    // Tokenize tool name
-    for (const word of tokenize(tool.name)) {
-      if (!GENERIC_WORDS.has(word) && !seen.has(word)) {
-        seen.add(word);
-        result.push(word);
-      }
-    }
-
-    // Extract from description
-    if (tool.description) {
-      for (const word of extractKeywords(tool.description)) {
-        if (!seen.has(word)) {
-          seen.add(word);
-          result.push(word);
-        }
-      }
-    }
-
-    if (result.length >= MAX_TRIGGERS) break;
-  }
-
-  return result.slice(0, MAX_TRIGGERS);
-}

package/src/mcp/types.ts

@@ -1,95 +0,0 @@
-// src/mcp/types.ts
-
-export interface McpAuth {
-  type: "oauth" | "bearer";
-  profile?: string;
-  envVar?: string;
-}
-
-export interface ServerConfig {
-  url?: string;
-  command?: string;
-  args?: string[];
-  transport: "http" | "stdio";
-  activation: "always" | "contextual" | "disabled";
-  taggable: boolean;
-  triggers: string[];
-  antiTriggers: string[];
-  auth?: McpAuth;
-  docsUrl?: string;
-  enabled: boolean;
-  authPending: boolean;
-  addedAt: string;
-}
-
-export interface McpRegistry {
-  schemaVersion: number;
-  servers: Record<string, ServerConfig>;
-}
-
-export interface McpTool {
-  name: string;
-  description: string;
-  inputSchema?: Record<string, unknown>;
-}
-
-export interface ToolCatalog {
-  serverName: string;
-  tools: McpTool[];
-  fetchedAt: string;
-}
-
-export type ServerStatus = "connected" | "disconnected" | "offline" | "auth-pending";
-
-export interface ServerState {
-  config: ServerConfig;
-  status: ServerStatus;
-  catalog?: ToolCatalog;
-}
-
-/** A server discovered from the OMP host MCP config (not yet in supipowers registry) */
-export interface HostMcpServer {
-  name: string;
-  scope: "user" | "project" | "claude-code";
-  transport: "http" | "stdio" | "sse";
-  url?: string;
-  command?: string;
-  args?: string[];
-  env?: Record<string, string>;
-  headers?: Record<string, string>;
-  enabled?: boolean;
-  hasAuth?: boolean;
-}
-
-/** mcpc exit codes per documentation */
-export const MCPC_EXIT = {
-  SUCCESS: 0,
-  CLIENT_ERROR: 1,
-  SERVER_ERROR: 2,
-  NETWORK_ERROR: 3,
-  AUTH_ERROR: 4,
-} as const;
-
-export function createEmptyRegistry(): McpRegistry {
-  return { schemaVersion: 1, servers: {} };
-}
-
-/** Reserved names that cannot be used as server names ($tag safety) */
-export const RESERVED_NAMES = new Set([
-  "path", "home", "user", "shell", "env", "pwd", "term", "lang",
-  "editor", "display", "host", "port", "http_proxy", "https_proxy", "no_proxy",
-]);
-
-/** Validate a server name */
-export function isValidServerName(name: string): { valid: boolean; reason?: string } {
-  if (name.length < 1 || name.length > 63) {
-    return { valid: false, reason: "Name must be 1-63 characters" };
-  }
-  if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(name)) {
-    return { valid: false, reason: "Lowercase alphanumeric and hyphens only, cannot start/end with hyphen" };
-  }
-  if (RESERVED_NAMES.has(name)) {
-    return { valid: false, reason: `"${name}" is reserved (conflicts with shell variables)` };
-  }
-  return { valid: true };
-}