Skip to content

x402agent/SolanaOS / skills/openclaw-claude-code-skill-main

claude-code-skill

Verified

Control Claude Code via MCP protocol. Trigger with "plan" to write a precise execution plan then feed it to Claude Code. Also supports direct commands, persistent sessions, agent teams, and advanced tool control.

FileKindSize
.gitignoreother277 B
LICENSEother1.0 KB
README.mdmarkdown13.9 KB
SKILL.mdskill md16.0 KB
examples/basic-mcp.tsscript1.4 KB
examples/chat-store.tsscript3.6 KB
mcp_config.example.jsonconfig648 B
package-lock.jsonmanifest20.9 KB
package.jsonmanifest679 B
src/index.tsscript35.3 KB
src/mcp/actions.tsscript9.4 KB
src/mcp/client.tsscript1.4 KB
src/mcp/index.tsscript189 B
src/mcp/logger.tsscript1.2 KB
src/mcp/types.tsscript3.2 KB
src/mcp/utils.tsscript477 B
src/store/index.tsscript148 B
src/store/indexeddb-storage.tsscript1.6 KB
src/store/persist.tsscript2.2 KB
src/store/sync.tsscript3.1 KB
tsconfig.jsonconfig399 B

src/mcp/types.ts

View on GitHub
/**
 * MCP (Model Context Protocol) Type Definitions
 * Reference: https://spec.modelcontextprotocol.io/specification/basic/messages/
 */

import { z } from "zod";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";

// MCP Request Message
export interface McpRequestMessage {
  jsonrpc?: "2.0";
  id?: string | number;
  method: "tools/call" | string;
  params?: {
    [key: string]: unknown;
  };
}

export const McpRequestMessageSchema: z.ZodType<McpRequestMessage> = z.object({
  jsonrpc: z.literal("2.0").optional(),
  id: z.union([z.string(), z.number()]).optional(),
  method: z.string(),
  params: z.record(z.unknown()).optional(),
});

// MCP Response Message
export interface McpResponseMessage {
  jsonrpc?: "2.0";
  id?: string | number;
  result?: {
    [key: string]: unknown;
  };
  error?: {
    code: number;
    message: string;
    data?: unknown;
  };
}

export const McpResponseMessageSchema: z.ZodType<McpResponseMessage> = z.object(
  {
    jsonrpc: z.literal("2.0").optional(),
    id: z.union([z.string(), z.number()]).optional(),
    result: z.record(z.unknown()).optional(),
    error: z
      .object({
        code: z.number(),
        message: z.string(),
        data: z.unknown().optional(),
      })
      .optional(),
  },
);

// MCP Notifications
export interface McpNotifications {
  jsonrpc?: "2.0";
  method: string;
  params?: {
    [key: string]: unknown;
  };
}

export const McpNotificationsSchema: z.ZodType<McpNotifications> = z.object({
  jsonrpc: z.literal("2.0").optional(),
  method: z.string(),
  params: z.record(z.unknown()).optional(),
});

// List Tools Response
export interface ListToolsResponse {
  tools: {
    name?: string;
    description?: string;
    inputSchema?: object;
    [key: string]: any;
  };
}

// MCP Client Data States
export type McpClientData =
  | McpActiveClient
  | McpErrorClient
  | McpInitializingClient;

interface McpInitializingClient {
  client: null;
  tools: null;
  errorMsg: null;
}

interface McpActiveClient {
  client: Client;
  tools: ListToolsResponse;
  errorMsg: null;
}

interface McpErrorClient {
  client: null;
  tools: null;
  errorMsg: string;
}

// Server Status Types
export type ServerStatus =
  | "undefined"
  | "active"
  | "paused"
  | "error"
  | "initializing";

export interface ServerStatusResponse {
  status: ServerStatus;
  errorMsg: string | null;
}

// MCP Server Configuration
export interface ServerConfig {
  command: string;
  args: string[];
  env?: Record<string, string>;
  status?: "active" | "paused" | "error";
}

export interface McpConfigData {
  mcpServers: Record<string, ServerConfig>;
}

export const DEFAULT_MCP_CONFIG: McpConfigData = {
  mcpServers: {},
};

// Arguments Mapping for Preset Servers
export interface ArgsMapping {
  type: "spread" | "single" | "env";
  position?: number;
  key?: string;
}

// Preset Server Configuration
export interface PresetServer {
  id: string;
  name: string;
  description: string;
  repo: string;
  tags: string[];
  command: string;
  baseArgs: string[];
  configurable: boolean;
  configSchema?: {
    properties: Record<
      string,
      {
        type: string;
        description?: string;
        required?: boolean;
        minItems?: number;
      }
    >;
  };
  argsMapping?: Record<string, ArgsMapping>;
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall