ccjk 5.2.0 → 5.2.2

package/dist/chunks/cloud-v5.mjs

@@ -0,0 +1,1651 @@
+import process__default from 'node:process';
+import { select, spinner, confirm } from '@clack/prompts';
+import * as ansis from 'ansis';
+
+class AgentOrchestratorClient {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "https://claude.iccjk.com";
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e5;
+  }
+  /**
+   * Set API key for authentication
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Get request headers
+   */
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Make API request
+   */
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}/api/v1/agents${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.getHeaders(),
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`API Error: ${error.message || response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // Orchestration APIs
+  // ========================================================================
+  /**
+   * Orchestrate a complex task with Cowork-style multi-agent execution
+   * POST /api/v1/agents/orchestrate
+   *
+   * @example
+   * ```ts
+   * const result = await client.orchestrate({
+   *   task: 'Review pull request and suggest improvements',
+   *   breakdown: true,
+   *   parallel: true,
+   *   subAgents: 2
+   * })
+   * ```
+   */
+  async orchestrate(request) {
+    return this.request("/orchestrate", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Get orchestration progress
+   * GET /api/v1/agents/:id/progress
+   *
+   * @example
+   * ```ts
+   * const progress = await client.getProgress('orch-id')
+   * console.log(`Progress: ${progress.progress}%`)
+   * console.log(`Current phase: ${progress.currentPhase}`)
+   * ```
+   */
+  async getProgress(orchestrationId) {
+    return this.request(`/${orchestrationId}/progress`);
+  }
+  /**
+   * Get queue status
+   * GET /api/v1/agents/queue-status
+   *
+   * @example
+   * ```ts
+   * const status = await client.getQueueStatus()
+   * console.log(`Pending: ${status.pending}`)
+   * console.log(`Est. wait: ${status.estimatedWaitTime}ms`)
+   * ```
+   */
+  async getQueueStatus() {
+    return this.request("/queue-status");
+  }
+  /**
+   * Cancel orchestration
+   * POST /api/v1/agents/:id/cancel
+   *
+   * @example
+   * ```ts
+   * await client.cancelOrchestration('orch-id')
+   * ```
+   */
+  async cancelOrchestration(orchestrationId) {
+    return this.request(`/${orchestrationId}/cancel`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Get available orchestration phases
+   * GET /api/v1/agents/phases
+   *
+   * @example
+   * ```ts
+   * const phases = await client.getPhases()
+   * phases.forEach(p => console.log(p.name))
+   * ```
+   */
+  async getPhases() {
+    return this.request("/phases");
+  }
+  // ========================================================================
+  // Utility Methods
+  // ========================================================================
+  /**
+   * Orchestrate and wait for completion (polling)
+   *
+   * @example
+   * ```ts
+   * const result = await client.orchestrateAndWait({
+   *   task: 'Generate API documentation',
+   *   breakdown: true
+   * })
+   * ```
+   */
+  async orchestrateAndWait(request, options = {}) {
+    const {
+      pollInterval = 2e3,
+      maxWaitTime = 6e5,
+      // 10 minutes
+      onProgress
+    } = options;
+    const orchestration = await this.orchestrate(request);
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitTime) {
+      const progress = await this.getProgress(orchestration.id);
+      onProgress?.(progress);
+      if (progress.status === "completed" || progress.status === "failed" || progress.status === "cancelled") {
+        return progress;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Orchestration timeout");
+  }
+  /**
+   * Stream orchestration progress using Server-Sent Events
+   *
+   * @example
+   * ```ts
+   * for await (const event of client.streamProgress('orch-id')) {
+   *   console.log(`Progress: ${event.progress}%`)
+   * }
+   * ```
+   */
+  async *streamProgress(orchestrationId) {
+    const url = `${this.baseUrl}/api/v1/agents/${orchestrationId}/progress/stream`;
+    const headers = this.getHeaders();
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to stream: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("Response body is not readable");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          try {
+            const data = JSON.parse(line.slice(6));
+            yield data;
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get sub-agent status
+   *
+   * @example
+   * ```ts
+   * const subAgents = await client.getSubAgentStatus('orch-id')
+   * subAgents.forEach(sa => {
+   *   console.log(`${sa.name}: ${sa.status} (${sa.progress}%)`)
+   * })
+   * ```
+   */
+  async getSubAgentStatus(orchestrationId) {
+    const progress = await this.getProgress(orchestrationId);
+    return progress.subAgents;
+  }
+  /**
+   * Get phase details
+   *
+   * @example
+   * ```ts
+   * const phases = await client.getPhaseDetails('orch-id')
+   * phases.forEach(p => {
+   *   console.log(`${p.name}: ${p.status} (${p.progress}%)`)
+   * })
+   * ```
+   */
+  async getPhaseDetails(orchestrationId) {
+    const progress = await this.getProgress(orchestrationId);
+    return progress.phases;
+  }
+}
+function createAgentOrchestratorClient(config) {
+  return new AgentOrchestratorClient(config);
+}
+
+class McpGatewayClient {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "https://claude.iccjk.com";
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+  }
+  /**
+   * Set API key for authentication
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Get request headers
+   */
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Make API request
+   */
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}/api/v1/mcp/gateway${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.getHeaders(),
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`API Error: ${error.message || response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // Gateway Info APIs
+  // ========================================================================
+  /**
+   * Get gateway information
+   * GET /api/v1/mcp/gateway
+   *
+   * @example
+   * ```ts
+   * const info = await client.getGatewayInfo()
+   * console.log(`Total servers: ${info.totalServers}`)
+   * console.log(`Total tools: ${info.totalTools}`)
+   * ```
+   */
+  async getGatewayInfo() {
+    return this.request("");
+  }
+  /**
+   * Get all MCP servers
+   * GET /api/v1/mcp/gateway/servers
+   *
+   * @example
+   * ```ts
+   * const servers = await client.getAllServers()
+   * console.log(`Found ${servers.length} servers`)
+   * ```
+   */
+  async getAllServers() {
+    return this.request("/servers");
+  }
+  /**
+   * Get Top 10 MCP servers
+   * GET /api/v1/mcp/gateway/top10
+   *
+   * @example
+   * ```ts
+   * const top10 = await client.getTop10()
+   * top10.forEach((server, index) => {
+   *   console.log(`${index + 1}. ${server.name}`)
+   * })
+   * ```
+   */
+  async getTop10() {
+    return this.request("/top10");
+  }
+  /**
+   * Get trending servers
+   * GET /api/v1/mcp/gateway/trending
+   *
+   * @example
+   * ```ts
+   * const trending = await client.getTrending()
+   * trending.forEach(t => {
+   *   console.log(`${t.server.name}: +${t.growth}%`)
+   * })
+   * ```
+   */
+  async getTrending() {
+    return this.request("/trending");
+  }
+  // ========================================================================
+  // Tool Search APIs
+  // ========================================================================
+  /**
+   * Search for tools across all servers
+   * GET /api/v1/mcp/gateway/tools/search
+   *
+   * @example
+   * ```ts
+   * const tools = await client.searchTools({
+   *   query: 'database query',
+   *   category: 'data',
+   *   limit: 10
+   * })
+   * ```
+   */
+  async searchTools(filters = {}) {
+    const params = new URLSearchParams();
+    if (filters.query)
+      params.append("q", filters.query);
+    if (filters.category)
+      params.append("category", filters.category);
+    if (filters.server)
+      params.append("server", filters.server);
+    if (filters.limit)
+      params.append("limit", filters.limit.toString());
+    const query = params.toString();
+    return this.request(`/tools/search${query ? `?${query}` : ""}`);
+  }
+  /**
+   * Get categories
+   * GET /api/v1/mcp/gateway/categories
+   *
+   * @example
+   * ```ts
+   * const categories = await client.getCategories()
+   * categories.forEach(cat => {
+   *   console.log(`${cat.name}: ${cat.count} tools`)
+   * })
+   * ```
+   */
+  async getCategories() {
+    return this.request("/categories");
+  }
+  // ========================================================================
+  // Tool Invocation APIs
+  // ========================================================================
+  /**
+   * Invoke a tool through the gateway
+   * POST /api/v1/mcp/gateway/invoke
+   *
+   * @example
+   * ```ts
+   * const result = await client.invokeTool({
+   *   tool: 'read_file',
+   *   server: 'mcp-filesystem',
+   *   args: { path: '/path/to/file.txt' }
+   * })
+   * ```
+   */
+  async invokeTool(request) {
+    return this.request("/invoke", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Batch invoke multiple tools
+   * POST /api/v1/mcp/gateway/invoke/batch
+   *
+   * @example
+   * ```ts
+   * const results = await client.invokeToolsBatch([
+   *   { tool: 'read_file', server: 'mcp-filesystem', args: { path: 'a.txt' } },
+   *   { tool: 'read_file', server: 'mcp-filesystem', args: { path: 'b.txt' } }
+   * ])
+   * ```
+   */
+  async invokeToolsBatch(requests) {
+    return this.request("/invoke/batch", {
+      method: "POST",
+      body: JSON.stringify({ requests })
+    });
+  }
+  // ========================================================================
+  // Compatibility APIs
+  // ========================================================================
+  /**
+   * Check tool compatibility
+   * POST /api/v1/mcp/gateway/compatibility
+   *
+   * @example
+   * ```ts
+   * const compatibility = await client.checkCompatibility({
+   *   tool: 'read_file',
+   *   server: 'mcp-filesystem'
+   * })
+   *
+   * if (!compatibility.compatible) {
+   *   console.log('Requirements:', compatibility.requirements)
+   * }
+   * ```
+   */
+  async checkCompatibility(request) {
+    return this.request("/compatibility", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  // ========================================================================
+  // Token Analysis APIs
+  // ========================================================================
+  /**
+   * Analyze token usage and get optimization suggestions
+   * POST /api/v1/mcp/gateway/analyze-tokens
+   *
+   * @example
+   * ```ts
+   * const analysis = await client.analyzeTokens({
+   *   content: 'Large document or codebase content...',
+   *   optimize: true
+   * })
+   *
+   * console.log(`Savings: ${analysis.savings} tokens`)
+   * console.log('Suggestions:', analysis.suggestions)
+   * ```
+   */
+  async analyzeTokens(content, optimize = true) {
+    return this.request("/analyze-tokens", {
+      method: "POST",
+      body: JSON.stringify({ content, optimize })
+    });
+  }
+  // ========================================================================
+  // Utility Methods
+  // ========================================================================
+  /**
+   * Get tools by server
+   *
+   * @example
+   * ```ts
+   * const tools = await client.getToolsByServer('mcp-filesystem')
+   * ```
+   */
+  async getToolsByServer(serverId) {
+    return this.request(`/servers/${serverId}/tools`);
+  }
+  /**
+   * Get server details
+   *
+   * @example
+   * ```ts
+   * const server = await client.getServerDetails('mcp-filesystem')
+   * console.log(server.name, server.description)
+   * ```
+   */
+  async getServerDetails(serverId) {
+    return this.request(`/servers/${serverId}`);
+  }
+  /**
+   * Invoke tool with automatic retry
+   *
+   * @example
+   * ```ts
+   * const result = await client.invokeToolWithRetry({
+   *   tool: 'query',
+   *   server: 'mcp-documentdb',
+   *   args: { query: 'SELECT * FROM users' }
+   * }, { maxRetries: 3 })
+   * ```
+   */
+  async invokeToolWithRetry(request, options = {}) {
+    const { maxRetries = 3, retryDelay = 1e3 } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await this.invokeTool(request);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (lastError.message.includes("HTTP 4") || lastError.message.includes("validation")) {
+          throw lastError;
+        }
+        if (attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay * (attempt + 1)));
+        }
+      }
+    }
+    throw new Error(String(lastError));
+  }
+}
+function createMcpGatewayClient(config) {
+  return new McpGatewayClient(config);
+}
+
+class MemorySystemClient {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "https://claude.iccjk.com";
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+  }
+  /**
+   * Set API key for authentication
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Get request headers
+   */
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Make API request
+   */
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}/api/v1/memory${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...this.getHeaders(),
+          ...options.headers
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`API Error: ${error.message || response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // Memory Capture APIs
+  // ========================================================================
+  /**
+   * Capture a memory
+   * POST /api/v1/memory/capture
+   *
+   * @example
+   * ```ts
+   * const memory = await client.captureMemory({
+   *   context: {
+   *     userAction: 'configured-theme',
+   *     theme: 'dark',
+   *     timestamp: new Date().toISOString()
+   *   },
+   *   tags: ['preference', 'theme'],
+   *   ttl: 86400 // 24 hours
+   * })
+   * ```
+   */
+  async captureMemory(request) {
+    return this.request("/capture", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Batch capture memories
+   * POST /api/v1/memory/capture-bulk
+   *
+   * @example
+   * ```ts
+   * const results = await client.captureMemoriesBatch({
+   *   memories: [
+   *     { context: { event: 'click', element: 'button' }, tags: ['interaction'] },
+   *     { context: { event: 'scroll', position: 500 }, tags: ['interaction'] }
+   *   ]
+   * })
+   * ```
+   */
+  async captureMemoriesBatch(request) {
+    return this.request("/capture-bulk", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  // ========================================================================
+  // Memory Recall APIs
+  // ========================================================================
+  /**
+   * Recall/search memories
+   * GET /api/v1/memory/recall
+   *
+   * @example
+   * ```ts
+   * const results = await client.recallMemories('user preferences')
+   * console.log(`Found ${results.memories.length} memories`)
+   * ```
+   */
+  async recallMemories(query, options = {}) {
+    const params = new URLSearchParams();
+    params.append("q", query);
+    if (options.limit)
+      params.append("limit", options.limit.toString());
+    if (options.sessionId)
+      params.append("sessionId", options.sessionId);
+    return this.request(`/recall?${params}`);
+  }
+  /**
+   * Search memories with filters
+   * GET /api/v1/memory/search
+   *
+   * @example
+   * ```ts
+   * const results = await client.searchMemories('theme', {
+   *   tags: ['preference'],
+   *   limit: 10
+   * })
+   * ```
+   */
+  async searchMemories(query, filters = {}) {
+    const params = new URLSearchParams();
+    params.append("q", query);
+    if (filters.limit)
+      params.append("limit", filters.limit.toString());
+    if (filters.sessionId)
+      params.append("sessionId", filters.sessionId);
+    if (filters.tags?.length)
+      params.append("tags", filters.tags.join(","));
+    return this.request(`/search?${params}`);
+  }
+  /**
+   * Surface related memories for a given memory
+   * GET /api/v1/memory/:id/surface
+   *
+   * @example
+   * ```ts
+   * const related = await client.surfaceRelatedMemories('memory-id', {
+   *   limit: 5,
+   *   threshold: 0.7
+   * })
+   * ```
+   */
+  async surfaceRelatedMemories(memoryId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit)
+      params.append("limit", options.limit.toString());
+    if (options.threshold)
+      params.append("threshold", options.threshold.toString());
+    return this.request(`/${memoryId}/surface?${params}`);
+  }
+  // ========================================================================
+  // Memory Management APIs
+  // ========================================================================
+  /**
+   * Delete a memory
+   * DELETE /api/v1/memory/:id
+   *
+   * @example
+   * ```ts
+   * await client.deleteMemory('memory-id')
+   * ```
+   */
+  async deleteMemory(memoryId) {
+    return this.request(`/${memoryId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Delete memories by tags
+   * DELETE /api/v1/memory/tags/:tag
+   *
+   * @example
+   * ```ts
+   * await client.deleteMemoriesByTag('temp')
+   * ```
+   */
+  async deleteMemoriesByTag(tag) {
+    return this.request(`/tags/${tag}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Get memory statistics
+   * GET /api/v1/memory/stats
+   *
+   * @example
+   * ```ts
+   * const stats = await client.getMemoryStats()
+   * console.log(`Total memories: ${stats.totalMemories}`)
+   * console.log(`Total clusters: ${stats.totalClusters}`)
+   * ```
+   */
+  async getMemoryStats() {
+    return this.request("/stats");
+  }
+  /**
+   * Get session memories
+   * GET /api/v1/memory/session/:sessionId
+   *
+   * @example
+   * ```ts
+   * const memories = await client.getSessionMemories('session-123')
+   * ```
+   */
+  async getSessionMemories(sessionId) {
+    return this.request(`/session/${sessionId}`);
+  }
+  // ========================================================================
+  // Memory Clustering APIs
+  // ========================================================================
+  /**
+   * Get memory clusters
+   * GET /api/v1/memory/clusters
+   *
+   * @example
+   * ```ts
+   * const clusters = await client.getClusters()
+   * clusters.forEach(c => {
+   *   console.log(`${c.name}: ${c.count} memories`)
+   * })
+   * ```
+   */
+  async getClusters() {
+    return this.request("/clusters");
+  }
+  /**
+   * Trigger manual clustering
+   * POST /api/v1/memory/cluster
+   *
+   * @example
+   * ```ts
+   * await client.triggerClustering({
+   *   algorithm: 'kmeans',
+   *   params: { clusters: 5 }
+   * })
+   * ```
+   */
+  async triggerClustering(request = {}) {
+    return this.request("/cluster", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Get cluster details
+   * GET /api/v1/memory/clusters/:clusterId
+   *
+   * @example
+   * ```ts
+   * const cluster = await client.getCluster('cluster-id')
+   * console.log(cluster.name, cluster.memories)
+   * ```
+   */
+  async getCluster(clusterId) {
+    return this.request(`/clusters/${clusterId}`);
+  }
+  // ========================================================================
+  // Maintenance APIs
+  // ========================================================================
+  /**
+   * Clean up expired memories
+   * POST /api/v1/memory/cleanup
+   *
+   * @example
+   * ```ts
+   * const result = await client.cleanupExpired()
+   * console.log(`Cleaned up ${result.deleted} memories`)
+   * ```
+   */
+  async cleanupExpired() {
+    return this.request("/cleanup", {
+      method: "POST"
+    });
+  }
+  /**
+   * Clean up by criteria
+   * POST /api/v1/memory/cleanup/advanced
+   *
+   * @example
+   * ```ts
+   * const result = await client.cleanup({
+   *   olderThan: '2026-01-01',
+   *   tags: ['temp']
+   * })
+   * ```
+   */
+  async cleanup(request) {
+    return this.request("/cleanup/advanced", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  // ========================================================================
+  // Utility Methods
+  // ========================================================================
+  /**
+   * Auto-capture context during session
+   *
+   * @example
+   * ```ts
+   * // Capture user actions automatically
+   * client.autoCapture('session-123', {
+   *   captureTags: ['interaction', 'preference'],
+   *   captureInterval: 60000 // every minute
+   * })
+   * ```
+   */
+  async autoCapture(sessionId, options = {}) {
+    await this.captureMemory({
+      context: {
+        type: "auto-capture",
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      tags: options.captureTags || ["auto"],
+      sessionId,
+      ttl: options.ttl
+    });
+  }
+  /**
+   * Build context from memories for AI
+   *
+   * @example
+   * ```ts
+   * const context = await client.buildContext('session-123', {
+   *   maxTokens: 2000,
+   *   includeTags: ['preference', 'important']
+   * })
+   * ```
+   */
+  async buildContext(sessionId, options = {}) {
+    const memories = await this.getSessionMemories(sessionId);
+    let filtered = memories;
+    if (options.includeTags?.length) {
+      filtered = memories.filter(
+        (m) => options.includeTags.some((tag) => m.tags.includes(tag))
+      );
+    }
+    const estimateTokens = (text) => Math.ceil(text.length / 4);
+    let context = "";
+    let tokensUsed = 0;
+    const maxTokens = options.maxTokens || 2e3;
+    for (const memory of filtered) {
+      const memoryText = JSON.stringify(memory.content);
+      const memoryTokens = estimateTokens(memoryText);
+      if (tokensUsed + memoryTokens > maxTokens) {
+        break;
+      }
+      context += `${memoryText}
+`;
+      tokensUsed += memoryTokens;
+    }
+    return {
+      context,
+      memoriesUsed: filtered.length,
+      tokensUsed
+    };
+  }
+}
+function createMemorySystemClient(config) {
+  return new MemorySystemClient(config);
+}
+
+class SessionTeleportationClient {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(config = {}) {
+    this.baseUrl = config.baseUrl ?? "https://claude.iccjk.com";
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}/api/v1/sessions${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: { ...this.getHeaders(), ...options.headers },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`API Error: ${error.message || response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  // ========================================================================
+  // Session Management APIs
+  // ========================================================================
+  /**
+   * Create a new session
+   * POST /api/v1/sessions
+   */
+  async createSession(request) {
+    return this.request("", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Get session by ID
+   * GET /api/v1/sessions/:id
+   */
+  async getSession(sessionId) {
+    return this.request(`/${sessionId}`);
+  }
+  /**
+   * List sessions
+   * GET /api/v1/sessions
+   */
+  async listSessions(filters) {
+    const params = new URLSearchParams();
+    if (filters?.type)
+      params.append("type", filters.type);
+    if (filters?.active !== void 0)
+      params.append("active", filters.active.toString());
+    if (filters?.limit)
+      params.append("limit", filters.limit.toString());
+    const query = params.toString();
+    return this.request(query ? `?${query}` : "");
+  }
+  /**
+   * Delete a session
+   * DELETE /api/v1/sessions/:id
+   */
+  async deleteSession(sessionId) {
+    return this.request(`/${sessionId}`, {
+      method: "DELETE"
+    });
+  }
+  // ========================================================================
+  // Teleportation APIs
+  // ========================================================================
+  /**
+   * Teleport session to another environment
+   * POST /api/v1/sessions/:id/teleport
+   */
+  async teleportSession(sessionId, request) {
+    return this.request(`/${sessionId}/teleport`, {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+  }
+  /**
+   * Activate a session
+   * POST /api/v1/sessions/:id/activate
+   */
+  async activateSession(sessionId) {
+    return this.request(`/${sessionId}/activate`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Deactivate a session
+   * POST /api/v1/sessions/:id/deactivate
+   */
+  async deactivateSession(sessionId) {
+    return this.request(`/${sessionId}/deactivate`, {
+      method: "POST"
+    });
+  }
+  // ========================================================================
+  // Statistics APIs
+  // ========================================================================
+  /**
+   * Get session statistics
+   * GET /api/v1/sessions/stats
+   */
+  async getStats() {
+    return this.request("/stats");
+  }
+  // ========================================================================
+  // Utility Methods
+  // ========================================================================
+  /**
+   * Get active sessions
+   */
+  async getActiveSessions() {
+    return this.listSessions({ active: true });
+  }
+  /**
+   * Get sessions by type
+   */
+  async getSessionsByType(type) {
+    return this.listSessions({ type });
+  }
+  /**
+   * Quick teleport (create and teleport in one call)
+   */
+  async quickTeleport(fromType, toType, context) {
+    const session = await this.createSession({
+      type: fromType,
+      initialContext: context
+    });
+    const result = await this.teleportSession(session.id, {
+      target: toType,
+      preserveContext: true
+    });
+    if (result.success && result.newSessionId) {
+      return this.getSession(result.newSessionId);
+    }
+    return session;
+  }
+}
+function createSessionTeleportationClient(config) {
+  return new SessionTeleportationClient(config);
+}
+
+const DEFAULT_ENDPOINT = "https://claude.iccjk.com";
+function loadConfig() {
+  return {
+    endpoint: process__default.env.CCJK_CLOUD_ENDPOINT || DEFAULT_ENDPOINT,
+    apiKey: process__default.env.CCJK_CLOUD_TOKEN,
+    timeout: Number.parseInt(process__default.env.CCJK_REQUEST_TIMEOUT || "30000", 10)
+  };
+}
+function printHeader(title, icon = "\u2601\uFE0F") {
+  console.log("");
+  console.log(ansis.bold.cyan("\u2501".repeat(60)));
+  console.log(ansis.bold.cyan(`  ${icon} ${title}`));
+  console.log(ansis.bold.cyan("\u2501".repeat(60)));
+  console.log("");
+}
+function printSuccess(message) {
+  console.log(ansis.green(`  \u2705 ${message}`));
+}
+function printError(message) {
+  console.log(ansis.red(`  \u274C ${message}`));
+}
+function printWarning(message) {
+  console.log(ansis.yellow(`  \u26A0\uFE0F  ${message}`));
+}
+function printInfo(message) {
+  console.log(ansis.dim(`  \u2139\uFE0F  ${message}`));
+}
+async function orchestrateCommand(args) {
+  printHeader("Agent Orchestrator", "\u{1F916}");
+  const config = loadConfig();
+  const client = createAgentOrchestratorClient(config);
+  let task = args.task;
+  if (!task) {
+    const result = await select({
+      message: "Select a task template:",
+      options: [
+        { value: "custom", label: "\u{1F4DD} Custom task..." },
+        { value: "analyze-codebase", label: "\u{1F50D} Analyze codebase and generate documentation" },
+        { value: "review-pr", label: "\u{1F440} Review pull request with detailed analysis" },
+        { value: "refactor", label: "\u267B\uFE0F  Refactor code with multiple agents" },
+        { value: "test-generation", label: "\u{1F9EA} Generate comprehensive test suite" },
+        { value: "debug-issue", label: "\u{1F41B} Debug complex issue with parallel analysis" }
+      ]
+    });
+    if (typeof result === "symbol")
+      return;
+    task = result === "custom" ? void 0 : result;
+  }
+  if (task !== "custom" && !task) {
+    printWarning("Please provide a task description");
+    return;
+  }
+  const breakdown = args.breakdown ?? await confirm({
+    message: "Auto-breakdown task into phases?",
+    initialValue: true
+  });
+  if (typeof breakdown === "symbol")
+    return;
+  const parallel = args.parallel ?? await confirm({
+    message: "Enable parallel sub-agent execution?",
+    initialValue: true
+  });
+  if (typeof parallel === "symbol")
+    return;
+  const subAgents = args.subAgents ?? (parallel ? 3 : 1);
+  const request = {
+    task: task || (args.task || ""),
+    breakdown,
+    parallel,
+    subAgents,
+    projectContext: {
+      rootDir: process__default.cwd()
+    }
+  };
+  console.log(ansis.dim(`
+  Task: ${request.task}`));
+  console.log(ansis.dim(`  Breakdown: ${request.breakdown}`));
+  console.log(ansis.dim(`  Parallel: ${request.parallel}`));
+  console.log(ansis.dim(`  Sub-agents: ${request.subAgents}`));
+  console.log("");
+  const shouldStart = await confirm({ message: "Start orchestration?", initialValue: true });
+  if (typeof shouldStart === "symbol" || !shouldStart)
+    return;
+  const s = spinner();
+  s.start("Submitting task to cloud orchestrator...");
+  try {
+    const orchestration = await client.orchestrate(request);
+    s.stop("Task submitted successfully!");
+    console.log(`
+  \u{1F4CB} Orchestration ID: ${orchestration.id}`);
+    console.log(`  \u{1F4CA} Status: ${orchestration.status}`);
+    if (args.watch) {
+      await watchOrchestrationProgress(client, orchestration.id);
+    } else {
+      printInfo(`Use --watch to monitor progress, or check status later`);
+      console.log(`  ccjk cloud status ${orchestration.id}`);
+    }
+  } catch (error) {
+    s.stop("Failed to submit task");
+    printError(error instanceof Error ? error.message : String(error));
+  }
+}
+async function watchOrchestrationProgress(client, orchestrationId) {
+  console.log("\n  \u{1F440} Watching orchestration progress...\n");
+  try {
+    for await (const progress of client.streamProgress(orchestrationId)) {
+      const statusIcon = {
+        pending: "\u23F3",
+        running: "\u{1F504}",
+        completed: "\u2705",
+        failed: "\u274C",
+        cancelled: "\u{1F6AB}"
+      }[progress.status] || "\u2753";
+      console.log(`\r  ${statusIcon} Progress: ${progress.progress}% | Phase: ${progress.currentPhase || "N/A"} | Sub-agents: ${progress.subAgents.filter((s) => s.status === "running").length}/${progress.subAgents.length}            `);
+      if (progress.status === "completed") {
+        console.log("\n");
+        printSuccess("Orchestration completed!");
+        if (progress.phases.length > 0) {
+          console.log("\n  \u{1F4CA} Phases:");
+          for (const phase of progress.phases) {
+            const icon = phase.status === "completed" ? "\u2705" : phase.status === "failed" ? "\u274C" : "\u23F3";
+            console.log(`     ${icon} ${phase.name} ${phase.progress !== void 0 ? `(${phase.progress}%)` : ""}`);
+          }
+        }
+        break;
+      }
+      if (progress.status === "failed") {
+        console.log("\n");
+        printError("Orchestration failed");
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  } catch (error) {
+    printError(`Failed to stream progress: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function orchestrationStatusCommand(args) {
+  printHeader("Orchestration Status", "\u{1F4CA}");
+  const config = loadConfig();
+  const client = createAgentOrchestratorClient(config);
+  const s = spinner();
+  s.start("Fetching orchestration status...");
+  try {
+    const progress = await client.getProgress(args.id);
+    s.stop("Status fetched");
+    console.log(`  \u{1F4CB} ID: ${progress.id}`);
+    console.log(`  \u{1F4CA} Status: ${progress.status}`);
+    console.log(`  \u{1F4C8} Progress: ${progress.progress}%`);
+    console.log(`  \u{1F3AF} Current Phase: ${progress.currentPhase || "N/A"}`);
+    console.log("");
+    if (progress.phases.length > 0) {
+      console.log("  \u{1F4CA} Phases:");
+      for (const phase of progress.phases) {
+        const icon = phase.status === "completed" ? "\u2705" : phase.status === "failed" ? "\u274C" : phase.status === "running" ? "\u{1F504}" : "\u23F3";
+        console.log(`     ${icon} ${phase.name}: ${phase.status} ${phase.progress !== void 0 ? `(${phase.progress}%)` : ""}`);
+      }
+    }
+    if (progress.subAgents.length > 0) {
+      console.log("\n  \u{1F916} Sub-agents:");
+      for (const agent of progress.subAgents) {
+        const icon = agent.status === "running" ? "\u{1F504}" : agent.status === "completed" ? "\u2705" : agent.status === "failed" ? "\u274C" : "\u{1F4A4}";
+        console.log(`     ${icon} ${agent.name} (${agent.role}): ${agent.status} ${agent.progress !== void 0 ? `(${agent.progress}%)` : ""}`);
+      }
+    }
+  } catch (error) {
+    s.stop("Failed to fetch status");
+    printError(error instanceof Error ? error.message : String(error));
+  }
+}
+async function mcpGatewayCommand(args) {
+  printHeader("MCP Gateway (10K+ Servers)", "\u{1F310}");
+  const config = loadConfig();
+  const client = createMcpGatewayClient(config);
+  const action = args.action || await select({
+    message: "What would you like to do?",
+    options: [
+      { value: "info", label: "\u{1F4CA} Show gateway info" },
+      { value: "top10", label: "\u{1F3C6} Show Top 10 servers" },
+      { value: "search", label: "\u{1F50D} Search tools" },
+      { value: "categories", label: "\u{1F4C1} Show categories" },
+      { value: "invoke", label: "\u26A1 Invoke a tool" }
+    ]
+  });
+  if (typeof action === "symbol")
+    return;
+  const s = spinner();
+  switch (action) {
+    case "info": {
+      s.start("Fetching gateway info...");
+      const info = await client.getGatewayInfo();
+      s.stop("Gateway info fetched");
+      console.log(`  \u{1F4CA} Total Servers: ${info.totalServers}`);
+      console.log(`  \u{1F527} Total Tools: ${info.totalTools}`);
+      console.log(`  \u{1F4C1} Categories: ${info.categories.length}`);
+      console.log(`  \u{1F550} Last Updated: ${new Date(info.lastUpdated).toLocaleString()}`);
+      break;
+    }
+    case "top10": {
+      s.start("Fetching Top 10 servers...");
+      const top10 = await client.getTop10();
+      s.stop("Top 10 fetched");
+      console.log("\n  \u{1F3C6} Top 10 MCP Servers:");
+      top10.forEach((server, index) => {
+        console.log(`
+     ${index + 1}. ${ansis.bold(server.name)}`);
+        console.log(`        ${server.description}`);
+        console.log(`        ${ansis.dim(`Category: ${server.category}${server.rank ? ` | Rank: #${server.rank}` : ""}`)}`);
+      });
+      break;
+    }
+    case "search": {
+      const query = args.query;
+      if (!query) {
+        printWarning("Please provide a search query with --query");
+        return;
+      }
+      s.start(`Searching for "${query}"...`);
+      const tools = await client.searchTools({ query, limit: 20 });
+      s.stop(`Found ${tools.length} tools`);
+      console.log("\n  \u{1F50D} Search Results:");
+      tools.forEach((tool) => {
+        console.log(`
+     ${ansis.bold(tool.name)} ${ansis.dim(`(${tool.server})`)}`);
+        console.log(`        ${tool.description}`);
+      });
+      break;
+    }
+    case "categories": {
+      s.start("Fetching categories...");
+      const categories = await client.getCategories();
+      s.stop("Categories fetched");
+      console.log("\n  \u{1F4C1} Categories:");
+      categories.forEach((cat) => {
+        console.log(`     ${cat.name}: ${cat.count} tools`);
+      });
+      break;
+    }
+    case "invoke": {
+      printInfo("Tool invocation requires --server and --tool parameters");
+      console.log("  Example: ccjk cloud mcp invoke --server mcp-filesystem --tool read_file");
+      break;
+    }
+  }
+  console.log("");
+}
+async function memoryCommand(args) {
+  printHeader("Memory System (Recallium)", "\u{1F9E0}");
+  const config = loadConfig();
+  const client = createMemorySystemClient(config);
+  const action = args.action || await select({
+    message: "What would you like to do?",
+    options: [
+      { value: "search", label: "\u{1F50D} Search memories" },
+      { value: "stats", label: "\u{1F4CA} Show memory statistics" },
+      { value: "clusters", label: "\u{1F5C2}\uFE0F Show memory clusters" },
+      { value: "capture", label: "\u{1F4BE} Capture a memory" },
+      { value: "cleanup", label: "\u{1F9F9} Cleanup expired memories" }
+    ]
+  });
+  if (typeof action === "symbol")
+    return;
+  const s = spinner();
+  switch (action) {
+    case "search": {
+      const query = args.query;
+      if (!query) {
+        printWarning("Please provide a search query with --query");
+        return;
+      }
+      s.start(`Searching for "${query}"...`);
+      const result = await client.searchMemories(query, { limit: 20 });
+      s.stop(`Found ${result.memories.length} memories`);
+      if (result.memories.length === 0) {
+        printInfo("No memories found");
+        break;
+      }
+      console.log("\n  \u{1F50D} Search Results:");
+      result.memories.forEach((memory) => {
+        console.log(`
+     \u{1F4DD} ${ansis.bold(JSON.stringify(memory.content).slice(0, 50))}`);
+        console.log(`        Tags: ${memory.tags.join(", ") || "none"}`);
+        console.log(`        Created: ${new Date(memory.createdAt).toLocaleString()}`);
+      });
+      break;
+    }
+    case "stats": {
+      s.start("Fetching memory statistics...");
+      const stats = await client.getMemoryStats();
+      s.stop("Statistics fetched");
+      console.log(`  \u{1F4CA} Total Memories: ${stats.totalMemories}`);
+      console.log(`  \u{1F5C2}\uFE0F  Total Clusters: ${stats.totalClusters}`);
+      console.log(`  \u{1F4C8} Avg Cluster Size: ${stats.avgClusterSize}`);
+      console.log(`  \u{1F550} Oldest: ${stats.oldestMemory ? new Date(stats.oldestMemory).toLocaleDateString() : "N/A"}`);
+      console.log(`  \u{1F550} Newest: ${stats.newestMemory ? new Date(stats.newestMemory).toLocaleDateString() : "N/A"}`);
+      break;
+    }
+    case "clusters": {
+      s.start("Fetching memory clusters...");
+      const clusters = await client.getClusters();
+      s.stop(`Found ${clusters.length} clusters`);
+      if (clusters.length === 0) {
+        printInfo("No clusters found");
+        break;
+      }
+      console.log("\n  \u{1F5C2}\uFE0F  Memory Clusters:");
+      clusters.forEach((cluster) => {
+        console.log(`
+     \u{1F4C1} ${ansis.bold(cluster.name)}`);
+        console.log(`        Count: ${cluster.count} | Tags: ${cluster.tags.join(", ")}`);
+      });
+      break;
+    }
+    case "capture": {
+      const content = args.capture;
+      if (!content) {
+        printWarning("Please provide content to capture with --capture");
+        return;
+      }
+      s.start("Capturing memory...");
+      const memory = await client.captureMemory({
+        context: { content },
+        tags: args.tags
+      });
+      s.stop("Memory captured");
+      printSuccess(`Memory captured with ID: ${memory.id}`);
+      break;
+    }
+    case "cleanup": {
+      s.start("Cleaning up expired memories...");
+      const result = await client.cleanupExpired();
+      s.stop(`Cleaned up ${result.deleted} memories`);
+      printSuccess(`Cleaned up ${result.deleted} expired memories`);
+      break;
+    }
+  }
+  console.log("");
+}
+async function sessionCommand(args) {
+  printHeader("Session Teleportation", "\u{1F300}");
+  const config = loadConfig();
+  const client = createSessionTeleportationClient(config);
+  const action = args.action || await select({
+    message: "What would you like to do?",
+    options: [
+      { value: "list", label: "\u{1F4CB} List sessions" },
+      { value: "create", label: "\u2795 Create session" },
+      { value: "teleport", label: "\u{1F300} Teleport session" },
+      { value: "stats", label: "\u{1F4CA} Session statistics" }
+    ]
+  });
+  if (typeof action === "symbol")
+    return;
+  const s = spinner();
+  switch (action) {
+    case "list": {
+      s.start("Fetching sessions...");
+      const sessions = await client.listSessions();
+      s.stop(`Found ${sessions.length} sessions`);
+      if (sessions.length === 0) {
+        printInfo("No active sessions");
+        break;
+      }
+      console.log("\n  \u{1F4CB} Active Sessions:");
+      sessions.forEach((session) => {
+        const icon = session.isActive ? "\u{1F7E2}" : "\u26AA";
+        console.log(`
+     ${icon} ${ansis.bold(session.id)}`);
+        console.log(`        Type: ${session.type} | Active: ${session.isActive}`);
+        console.log(`        Context: ${session.contextSize} tokens`);
+        console.log(`        Created: ${new Date(session.createdAt).toLocaleString()}`);
+      });
+      break;
+    }
+    case "create": {
+      const type = args.type || await select({
+        message: "Session type:",
+        options: [
+          { value: "terminal", label: "\u{1F4BB} Terminal" },
+          { value: "desktop", label: "\u{1F5A5}\uFE0F  Desktop" },
+          { value: "web", label: "\u{1F310} Web" }
+        ]
+      });
+      if (typeof type === "symbol")
+        return;
+      s.start("Creating session...");
+      const session = await client.createSession({
+        type,
+        projectPath: process__default.cwd()
+      });
+      s.stop("Session created");
+      printSuccess(`Session created with ID: ${session.id}`);
+      console.log(`  Type: ${session.type}`);
+      console.log(`  Project: ${session.projectPath || "default"}`);
+      break;
+    }
+    case "teleport": {
+      const sessionId = args.sessionId;
+      if (!sessionId) {
+        printWarning("Please provide session ID with --sessionId");
+        return;
+      }
+      const target = args.target || await select({
+        message: "Target environment:",
+        options: [
+          { value: "terminal", label: "\u{1F4BB} Terminal" },
+          { value: "desktop", label: "\u{1F5A5}\uFE0F  Desktop" },
+          { value: "web", label: "\u{1F310} Web" }
+        ]
+      });
+      if (typeof target === "symbol")
+        return;
+      s.start(`Teleporting session to ${target}...`);
+      const result = await client.teleportSession(sessionId, {
+        target,
+        preserveContext: true
+      });
+      s.stop("Session teleported");
+      if (result.success) {
+        printSuccess(`Session teleported successfully!`);
+        if (result.newSessionId) {
+          console.log(`  New Session ID: ${result.newSessionId}`);
+        }
+      } else {
+        printError(result.message || "Teleportation failed");
+      }
+      break;
+    }
+    case "stats": {
+      s.start("Fetching session statistics...");
+      const stats = await client.getStats();
+      s.stop("Statistics fetched");
+      console.log(`  \u{1F4CA} Total Sessions: ${stats.totalSessions}`);
+      console.log(`  \u{1F7E2} Active Sessions: ${stats.activeSessions}`);
+      console.log("  \u{1F4CA} Type Breakdown:");
+      for (const [type, count] of Object.entries(stats.typeBreakdown)) {
+        console.log(`     ${type}: ${count}`);
+      }
+      break;
+    }
+  }
+  console.log("");
+}
+async function cloudV5Command(subcommand, args = {}) {
+  console.log("");
+  if (!subcommand) {
+    await cloudV5Menu();
+    return;
+  }
+  switch (subcommand) {
+    // Agent Orchestrator
+    case "orchestrate":
+    case "orch":
+      await orchestrateCommand(args);
+      break;
+    case "orchestrate-status":
+    case "status":
+      if (args.id) {
+        await orchestrationStatusCommand({ id: String(args.id) });
+      } else {
+        printWarning("Please provide orchestration ID with --id");
+      }
+      break;
+    // MCP Gateway
+    case "mcp":
+    case "mcp-gateway":
+      await mcpGatewayCommand(args);
+      break;
+    // Memory System
+    case "memory":
+    case "mem":
+      await memoryCommand(args);
+      break;
+    // Session Teleportation
+    case "session":
+    case "teleport":
+      await sessionCommand(args);
+      break;
+    // Help
+    case "help":
+    case "--help":
+    case "-h":
+      showCloudV5Help();
+      break;
+    default:
+      printError(`Unknown subcommand: ${subcommand}`);
+      showCloudV5Help();
+  }
+}
+async function cloudV5Menu() {
+  printHeader("CCJK Cloud v5.1.0-2026", "\u2601\uFE0F");
+  const options = [
+    { value: "orchestrate", label: "\u{1F916} Agent Orchestrator - Cowork-inspired multi-agent tasks" },
+    { value: "mcp", label: "\u{1F310} MCP Gateway - Access 10,000+ MCP servers" },
+    { value: "memory", label: "\u{1F9E0} Memory System - Recallium universal memory" },
+    { value: "session", label: "\u{1F300} Session Teleportation - Cross-device sessions" },
+    { value: "help", label: "\u2753 Help" },
+    { value: "exit", label: "\u{1F519} Exit" }
+  ];
+  while (true) {
+    const action = await select({
+      message: "Select a feature:",
+      options
+    });
+    if (typeof action === "symbol")
+      break;
+    switch (action) {
+      case "orchestrate":
+        await orchestrateCommand({});
+        break;
+      case "mcp":
+        await mcpGatewayCommand({});
+        break;
+      case "memory":
+        await memoryCommand({});
+        break;
+      case "session":
+        await sessionCommand({});
+        break;
+      case "help":
+        showCloudV5Help();
+        break;
+      case "exit":
+        console.log("");
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+}
+function showCloudV5Help() {
+  console.log("");
+  console.log(ansis.bold("Usage:"));
+  console.log("  ccjk cloud <subcommand> [options]");
+  console.log("");
+  console.log(ansis.bold("Subcommands:"));
+  console.log(ansis.cyan("  Agent Orchestrator:"));
+  console.log("    orchestrate          Orchestrate a multi-agent task");
+  console.log("    orchestrate-status    Show orchestration status");
+  console.log("");
+  console.log(ansis.cyan("  MCP Gateway:"));
+  console.log("    mcp                  Open MCP Gateway menu");
+  console.log("");
+  console.log(ansis.cyan("  Memory System:"));
+  console.log("    memory               Open Memory System menu");
+  console.log("");
+  console.log(ansis.cyan("  Session Teleportation:"));
+  console.log("    session              Open Session Teleportation menu");
+  console.log("");
+  console.log(ansis.bold("Options:"));
+  console.log("  --endpoint <url>     Cloud service endpoint");
+  console.log("  --token <token>       API authentication token");
+  console.log("  --watch               Watch progress in real-time");
+  console.log("");
+}
+
+export { cloudV5Command, mcpGatewayCommand, memoryCommand, orchestrateCommand, orchestrationStatusCommand, sessionCommand };