aws-runtime-bridge 1.0.0 → 1.0.1

package/node_modules/@cc-switch/sdk/README.md

@@ -0,0 +1,541 @@
+# @cc-switch/sdk
+
+Node SDK for MCP and Skill management, mirroring CC Switch's unified storage + per-app sync architecture.
+
+## Features
+
+- **MCP Servers**: CRUD + app enable/disable + import from apps (Claude, Claudecode, OpenCode)
+- **Skills**: Install/uninstall + directory sync (copy/symlink) + import from apps
+- **Config Backup/Restore**: Auto backup before first Opencode/Claudecode sync + restore methods
+- **Extensible**: Placeholder adapters for Codex/Gemini/OpenClaw (easy to implement)
+
+## Installation
+
+```bash
+npm install @cc-switch/sdk
+```
+
+## Quick Start
+
+```typescript
+import { CcSwitchSdk } from "@cc-switch/sdk";
+
+const sdk = new CcSwitchSdk();
+await sdk.load();
+
+// Create MCP server
+const server = await sdk.createMcpServer({
+  name: "my-mcp",
+  server: { type: "stdio", command: "node", args: ["server.js"] },
+  apps: { claude: true },
+});
+
+// Toggle app
+await sdk.toggleMcpApp(server.id, "opencode", true);
+
+// Import from apps
+await sdk.importMcpFromApps();
+
+// Install skill
+await sdk.installSkill({
+  sourceDir: "/path/to/skill",
+  name: "my-skill",
+  apps: { claude: true, opencode: true },
+});
+```
+
+## Configuration
+
+```typescript
+const sdk = new CcSwitchSdk({
+  rootDir: "/custom/path",        // Base directory
+  skillSyncMethod: "symlink",     // "auto" | "copy" | "symlink"
+  paths: {
+    stateFile: "...",
+    backupDir: "...",               // backup directory
+    claudeConfigFile: "...",
+    claudeSkillsDir: "...",
+    claudecodeConfigFile: "...",    // claudecode mcp config
+    claudecodeSkillsDir: "...",
+    opencodeConfigFile: "...",
+    opencodeSkillsDir: "...",
+    ssotSkillsDir: "...",
+  },
+  // Custom adapters
+  adapters: {
+    mcp: { codex: new MyCodexAdapter() },
+    skill: { codex: new MyCodexSkillAdapter() },
+  },
+});
+```
+
+---
+
+## API Reference
+
+### Class: `CcSwitchSdk`
+
+Main SDK class for managing MCP servers and Skills.
+
+#### Constructor
+
+```typescript
+constructor(options?: SdkOptions)
+```
+
+**Parameters:**
+- `options.rootDir` (string, optional): Base directory for all SDK operations
+- `options.skillSyncMethod` ("auto" | "copy" | "symlink", optional): Method for syncing skill directories
+- `options.paths` (Partial\<SdkPaths\>, optional): Custom paths for config files
+- `options.adapters` (AdapterOverrides, optional): Custom adapters for MCP and Skill management
+
+---
+
+### MCP Server Management
+
+#### `load(): Promise<void>`
+
+Load SDK state from disk. **Must be called before any operations.**
+
+```typescript
+await sdk.load();
+```
+
+---
+
+#### `save(): Promise<void>`
+
+Manually save SDK state to disk.
+
+```typescript
+await sdk.save();
+```
+
+---
+
+#### `createMcpServer(input: CreateMcpInput): Promise<McpServer>`
+
+Create a new MCP server and sync to enabled apps.
+
+**Parameters:**
+- `input.name` (string): Unique server name
+- `input.server` (McpServerSpec): Server configuration
+- `input.apps` (Partial\<AppFlags\>, optional): Target apps
+- `input.description` (string, optional): Server description
+
+**Returns:** `McpServer` - Created server object
+
+```typescript
+const server = await sdk.createMcpServer({
+  name: "aws-mcp",
+  server: {
+    type: "stdio",
+    command: "node",
+    args: ["index.js"],
+    env: { API_KEY: "secret" }
+  },
+  apps: { claude: true, opencode: true },
+  description: "AWS MCP Server"
+});
+```
+
+---
+
+#### `getAllMcpServers(): McpServer[]`
+
+Get all MCP servers.
+
+```typescript
+const servers = sdk.getAllMcpServers();
+// Returns: McpServer[]
+```
+
+---
+
+#### `getMcpServerById(id: string): McpServer | undefined`
+
+Get MCP server by ID.
+
+```typescript
+const server = sdk.getMcpServerById("mcp_abc123");
+```
+
+---
+
+#### `updateMcpServer(id: string, patch: UpdateMcpInput): Promise<McpServer>`
+
+Update MCP server configuration.
+
+**Parameters:**
+- `id`: Server ID
+- `patch`: Partial server update
+
+```typescript
+const updated = await sdk.updateMcpServer(server.id, {
+  description: "Updated description",
+  apps: { claudecode: true }
+});
+```
+
+---
+
+#### `deleteMcpServer(id: string): Promise<void>`
+
+Delete MCP server and remove from all apps.
+
+```typescript
+await sdk.deleteMcpServer(server.id);
+```
+
+---
+
+#### `toggleMcpApp(serverId: string, appId: AppId, enabled: boolean): Promise<McpServer>`
+
+Enable or disable MCP server for a specific app.
+
+```typescript
+await sdk.toggleMcpApp(server.id, "opencode", true);
+```
+
+---
+
+#### `importMcpFromApps(): Promise<number>`
+
+Import MCP servers from all apps into SDK state.
+
+**Returns:** Number of imported servers
+
+```typescript
+const count = await sdk.importMcpFromApps();
+console.log(`Imported ${count} servers`);
+```
+
+---
+
+### Skill Management
+
+#### `installSkill(input: CreateSkillInput): Promise<InstalledSkill>`
+
+Install a skill and sync to enabled apps.
+
+**Parameters:**
+- `input.sourceDir` (string): Source directory containing skill files
+- `input.name` (string): Skill name
+- `input.apps` (Partial\<AppFlags\>, optional): Target apps
+- `input.description` (string, optional): Skill description
+
+```typescript
+const skill = await sdk.installSkill({
+  sourceDir: "/path/to/skill/source",
+  name: "frontend-design",
+  apps: { claude: true, opencode: true },
+  description: "Frontend design skill"
+});
+```
+
+---
+
+#### `getAllSkills(): InstalledSkill[]`
+
+Get all installed skills.
+
+```typescript
+const skills = sdk.getAllSkills();
+```
+
+---
+
+#### `getSkillById(id: string): InstalledSkill | undefined`
+
+Get skill by ID.
+
+```typescript
+const skill = sdk.getSkillById("skill_abc123");
+```
+
+---
+
+#### `updateSkill(id: string, patch: UpdateSkillInput): Promise<InstalledSkill>`
+
+Update skill configuration.
+
+```typescript
+const updated = await sdk.updateSkill(skill.id, {
+  description: "Updated description"
+});
+```
+
+---
+
+#### `uninstallSkill(id: string): Promise<void>`
+
+Uninstall skill and remove from all apps.
+
+```typescript
+await sdk.uninstallSkill(skill.id);
+```
+
+---
+
+#### `toggleSkillApp(skillId: string, appId: AppId, enabled: boolean): Promise<InstalledSkill>`
+
+Enable or disable skill for a specific app.
+
+```typescript
+await sdk.toggleSkillApp(skill.id, "claude", false);
+```
+
+---
+
+#### `importSkillsFromApps(): Promise<number>`
+
+Import skills from all apps into SDK state.
+
+```typescript
+const count = await sdk.importSkillsFromApps();
+```
+
+---
+
+### Backup & Restore
+
+#### `backupAiConfigs(appIds?: AppId[]): Promise<void>`
+
+Backup AI config files before modification.
+
+```typescript
+await sdk.backupAiConfigs(["opencode", "claudecode"]);
+```
+
+---
+
+#### `restoreAiConfig(appId: AppId): Promise<boolean>`
+
+Restore AI config from backup.
+
+**Returns:** `true` if restored successfully
+
+```typescript
+const restored = await sdk.restoreAiConfig("opencode");
+if (restored) {
+  console.log("Config restored");
+}
+```
+
+---
+
+#### `restoreAiConfigs(appIds?: AppId[]): Promise<Record<string, boolean>>`
+
+Restore multiple AI configs.
+
+```typescript
+const results = await sdk.restoreAiConfigs(["opencode", "claudecode"]);
+// Returns: { opencode: true, claudecode: false }
+```
+
+---
+
+### Utility Methods
+
+#### `getPaths(): SdkPaths`
+
+Get current SDK paths configuration.
+
+```typescript
+const paths = sdk.getPaths();
+console.log(paths.stateFile);
+```
+
+---
+
+## Types
+
+### `AppId`
+
+```typescript
+type AppId = "claude" | "claudecode" | "codex" | "gemini" | "opencode" | "openclaw";
+```
+
+### `McpServerSpec`
+
+```typescript
+interface McpServerSpec {
+  type?: "stdio" | "sse" | "http";
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+  url?: string;
+  headers?: Record<string, string>;
+}
+```
+
+### `McpServer`
+
+```typescript
+interface McpServer {
+  id: string;
+  name: string;
+  server: McpServerSpec;
+  description?: string;
+  apps: AppFlags;
+}
+```
+
+### `InstalledSkill`
+
+```typescript
+interface InstalledSkill {
+  id: string;
+  name: string;
+  directory: string;
+  description?: string;
+  apps: AppFlags;
+  installedAt: number;
+}
+```
+
+### `AppFlags`
+
+```typescript
+interface AppFlags {
+  claude: boolean;
+  claudecode: boolean;
+  codex: boolean;
+  gemini: boolean;
+  opencode: boolean;
+  openclaw: boolean;
+}
+```
+
+---
+
+## Extending
+
+### Custom MCP Adapter
+
+Implement `IMcpAdapter` to add support for new apps:
+
+```typescript
+import type { IMcpAdapter, McpServer } from "@cc-switch/sdk";
+
+class MyCodexAdapter implements IMcpAdapter {
+  readonly appId = "codex" as const;
+
+  async importServers(): Promise<McpServer[]> {
+    // Read existing MCP servers from Codex config
+    // Return array of McpServer objects
+  }
+
+  async syncServer(server: McpServer): Promise<void> {
+    // Write MCP server to Codex config
+  }
+
+  async removeServer(server: McpServer): Promise<void> {
+    // Remove MCP server from Codex config
+  }
+}
+```
+
+### Custom Skill Adapter
+
+Implement `ISkillAdapter` for skill management:
+
+```typescript
+import type { ISkillAdapter, InstalledSkill, SkillSyncMethod } from "@cc-switch/sdk";
+
+class MyCodexSkillAdapter implements ISkillAdapter {
+  readonly appId = "codex" as const;
+
+  async importSkills(): Promise<Array<Pick<InstalledSkill, "id" | "name" | "directory" | "description">>> {
+    // Scan skill directories
+    // Return array of skill info
+  }
+
+  async syncSkill(skill: InstalledSkill, sourceDir: string, method: SkillSyncMethod): Promise<void> {
+    // Copy or symlink skill directory
+  }
+
+  async removeSkill(skill: InstalledSkill): Promise<void> {
+    // Remove skill directory
+  }
+}
+```
+
+### Using Custom Adapters
+
+```typescript
+const sdk = new CcSwitchSdk({
+  adapters: {
+    mcp: { codex: new MyCodexAdapter() },
+    skill: { codex: new MyCodexSkillAdapter() }
+  }
+});
+```
+
+---
+
+## Error Handling
+
+SDK throws `SdkError` for known errors:
+
+```typescript
+import { SdkError } from "@cc-switch/sdk";
+
+try {
+  await sdk.updateMcpServer("invalid-id", {});
+} catch (err) {
+  if (err instanceof SdkError) {
+    console.log(err.code);    // "MCP_NOT_FOUND"
+    console.log(err.message); // "MCP server not found: invalid-id"
+    console.log(err.details); // { id: "invalid-id" }
+  }
+}
+```
+
+**Error Codes:**
+- `MCP_NOT_FOUND`: MCP server not found
+- `SKILL_NOT_FOUND`: Skill not found
+
+---
+
+## Scripts
+
+```bash
+pnpm typecheck   # TypeScript check
+pnpm build       # Compile
+pnpm test        # Run tests
+```
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────┐
+│         CcSwitchSdk (Core)          │
+│  - State Management                 │
+│  - CRUD Operations                  │
+│  - Import/Export                    │
+└──────────────┬──────────────────────┘
+               │
+    ┌──────────┴──────────┐
+    │                     │
+┌───▼────┐          ┌────▼───┐
+│ MCP    │          │ Skill  │
+│ Service│          │ Service│
+└───┬────┘          └────┬───┘
+    │                    │
+┌───▼────────────────────▼───┐
+│      Adapters Layer        │
+│  - Claude / Claudecode     │
+│  - OpenCode                │
+│  - Codex / Gemini / ...    │
+└────────────────────────────┘
+```
+
+---
+
+## License
+
+MIT

package/node_modules/@cc-switch/sdk/dist/adapters/common.d.ts

@@ -0,0 +1,38 @@
+import type { AppId, McpServer, McpServerSpec } from "../types.js";
+export type JsonRecord = Record<string, unknown>;
+export interface ClaudeConfig {
+    mcpServers?: Record<string, McpServerSpec>;
+    [key: string]: unknown;
+}
+export interface OpenCodeLocalServer {
+    type: "local";
+    command: string[];
+    environment?: Record<string, string>;
+    cwd?: string;
+    enabled?: boolean;
+}
+export interface OpenCodeRemoteServer {
+    type: "remote";
+    url: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+}
+export type OpenCodeServer = OpenCodeLocalServer | OpenCodeRemoteServer;
+export interface OpenCodeConfig {
+    mcp?: Record<string, OpenCodeServer>;
+    mcpServers?: Record<string, OpenCodeServer>;
+    [key: string]: unknown;
+}
+export type ClaudecodeLocalServer = OpenCodeLocalServer;
+export type ClaudecodeRemoteServer = OpenCodeRemoteServer;
+export type ClaudecodeServer = OpenCodeServer;
+export interface ClaudecodeConfig {
+    mcpServers?: Record<string, ClaudecodeServer>;
+    [key: string]: unknown;
+}
+export declare function toMcpSpecFromOpenCode(input: OpenCodeServer): McpServerSpec;
+export declare function toOpenCodeServer(input: McpServerSpec): OpenCodeServer;
+export declare function mergeAppFlagOnImport(server: McpServer, appId: AppId): McpServer;
+export declare const toMcpSpecFromClaudecode: typeof toMcpSpecFromOpenCode;
+export declare const toClaudecodeServer: typeof toOpenCodeServer;
+//# sourceMappingURL=common.d.ts.map

package/node_modules/@cc-switch/sdk/dist/adapters/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/adapters/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEnE,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,QAAQ,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,oBAAoB,CAAC;AAExE,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC5C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAGD,MAAM,MAAM,qBAAqB,GAAG,mBAAmB,CAAC;AACxD,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE9C,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC9C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,aAAa,CAiB1E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAoBrE;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,KAAK,GACX,SAAS,CAQX;AAGD,eAAO,MAAM,uBAAuB,8BAAwB,CAAC;AAC7D,eAAO,MAAM,kBAAkB,yBAAmB,CAAC"}

package/node_modules/@cc-switch/sdk/dist/adapters/common.js

@@ -0,0 +1,47 @@
+export function toMcpSpecFromOpenCode(input) {
+    if (input.type === "local") {
+        const [command, ...args] = input.command;
+        return {
+            type: "stdio",
+            command,
+            args,
+            env: input.environment,
+            cwd: input.cwd,
+        };
+    }
+    return {
+        type: "sse",
+        url: input.url,
+        headers: input.headers,
+    };
+}
+export function toOpenCodeServer(input) {
+    if (input.type === "stdio") {
+        const commandParts = [input.command, ...(input.args ?? [])].filter((entry) => Boolean(entry));
+        return {
+            type: "local",
+            command: commandParts,
+            environment: input.env,
+            cwd: input.cwd,
+            enabled: true,
+        };
+    }
+    return {
+        type: "remote",
+        url: input.url ?? "",
+        headers: input.headers,
+        enabled: true,
+    };
+}
+export function mergeAppFlagOnImport(server, appId) {
+    return {
+        ...server,
+        apps: {
+            ...server.apps,
+            [appId]: true,
+        },
+    };
+}
+// Claudecode uses the same conversion functions as OpenCode
+export const toMcpSpecFromClaudecode = toMcpSpecFromOpenCode;
+export const toClaudecodeServer = toOpenCodeServer;

package/node_modules/@cc-switch/sdk/dist/adapters/index.d.ts

@@ -0,0 +1,5 @@
+import type { AppId, IMcpAdapter, SdkPaths } from "../types.js";
+import type { ISkillAdapter } from "../types.js";
+export declare function createMcpAdapters(paths: SdkPaths): Record<AppId, IMcpAdapter>;
+export declare function createSkillAdapters(paths: SdkPaths): Record<AppId, ISkillAdapter>;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@cc-switch/sdk/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAShE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAAC,KAAK,EAAE,WAAW,CAAC,CAS7E;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,GACd,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,CAS9B"}

package/node_modules/@cc-switch/sdk/dist/adapters/index.js

@@ -0,0 +1,28 @@
+import { ClaudeMcpAdapter } from "./mcp-claude.js";
+import { ClaudecodeMcpAdapter } from "./mcp-claudecode.js";
+import { OpenCodeMcpAdapter } from "./mcp-opencode.js";
+import { PlaceholderMcpAdapter } from "./mcp-placeholder.js";
+import { ClaudeSkillAdapter } from "./skill-claude.js";
+import { ClaudecodeSkillAdapter } from "./skill-claudecode.js";
+import { OpenCodeSkillAdapter } from "./skill-opencode.js";
+import { PlaceholderSkillAdapter } from "./skill-placeholder.js";
+export function createMcpAdapters(paths) {
+    return {
+        claude: new ClaudeMcpAdapter(paths.claudeConfigFile),
+        claudecode: new ClaudecodeMcpAdapter(paths.claudecodeConfigFile),
+        opencode: new OpenCodeMcpAdapter(paths.opencodeConfigFile),
+        codex: new PlaceholderMcpAdapter("codex"),
+        gemini: new PlaceholderMcpAdapter("gemini"),
+        openclaw: new PlaceholderMcpAdapter("openclaw"),
+    };
+}
+export function createSkillAdapters(paths) {
+    return {
+        claude: new ClaudeSkillAdapter(paths.claudeSkillsDir),
+        claudecode: new ClaudecodeSkillAdapter(paths.claudecodeSkillsDir),
+        opencode: new OpenCodeSkillAdapter(paths.opencodeSkillsDir),
+        codex: new PlaceholderSkillAdapter("codex"),
+        gemini: new PlaceholderSkillAdapter("gemini"),
+        openclaw: new PlaceholderSkillAdapter("openclaw"),
+    };
+}

package/node_modules/@cc-switch/sdk/dist/adapters/mcp-claude.d.ts

@@ -0,0 +1,10 @@
+import type { IMcpAdapter, McpServer } from "../types.js";
+export declare class ClaudeMcpAdapter implements IMcpAdapter {
+    private readonly configPath;
+    readonly appId: "claude";
+    constructor(configPath: string);
+    importServers(): Promise<McpServer[]>;
+    syncServer(server: McpServer): Promise<void>;
+    removeServer(server: McpServer): Promise<void>;
+}
+//# sourceMappingURL=mcp-claude.d.ts.map

package/node_modules/@cc-switch/sdk/dist/adapters/mcp-claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-claude.d.ts","sourceRoot":"","sources":["../../src/adapters/mcp-claude.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAK1D,qBAAa,gBAAiB,YAAW,WAAW;IAGtC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,SAAgB,KAAK,EAAG,QAAQ,CAAU;gBAEb,UAAU,EAAE,MAAM;IAEzC,aAAa,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAmBrC,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CASrD"}