cloudflare-mcp-smart-proxy 1.2.0 → 1.3.0

package/README.md

@@ -1,188 +1,120 @@
-# @cloudflare-mcp/smart-proxy
+# CLOUDMCP Local Proxy
 
-智能路由代理，自动将 MCP 工具请求路由到云端或本地执行。
+`local-proxy` 是 `CLOUDMCP` 当前主线的参考连接器实现。
 
-## 功能特性
+它包含两层能力：
 
-- ✅ **智能路由**: 自动判断工具应该路由到云端还是本地
-- ✅ **本地文件编辑**: 支持读取、写入、差异编辑本地文件
-- ✅ **云端工具集成**: 无缝使用 Cloudflare MCP 的云端工具
-- ✅ **统一接口**: AI 看到的是合并后的工具列表
-- ✅ **零配置**: 通过 npx 自动安装和使用
+- `index.js`
+  - stdio MCP server，负责把本地工具和云端 `CLOUDMCP` 工具统一暴露给宿主生态
+- `connector-cli.js`
+  - 参考连接器安装器，负责把这条 stdio 入口写进目标生态的原生配置文件
 
-## 工具路由规则
+自 A3 起，官方优先支持两个生态：
 
-### 本地工具（直接执行）
+- `codex`
+- `claude_code`
 
-- `read_file` - 读取本地文件
-- `write_file` - 写入本地文件
-- `edit_file` - 差异编辑本地文件
-- `list_dir` - 列出本地目录
-- `delete_file` - 删除本地文件
-- `execute_command` - 执行本地命令
+## 当前入口
 
-### 云端工具（转发到 Cloudflare Workers）
-
-- `web_search` - 网络搜索
-- `github_*` - GitHub API 操作
-- `memory_*` - 记忆工具
-- `library_docs` - 库文档查询
-- `codebase_search` - R2 代码库搜索
-- 其他所有未匹配的工具
-
-## 安装
-
-### 方法 1: 使用安装脚本（推荐）
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/your-repo/local-proxy/main/install.sh | bash
-```
-
-或下载后执行：
+### 1. 作为 MCP stdio server 运行
 
 ```bash
-chmod +x install.sh
-./install.sh
+cd /home/coder/project/CLOUDMCP/local-proxy
+export CLOUDFLARE_MCP_URL="https://your-cloudmcp.example.com"
+export CLOUDFLARE_MCP_API_KEY="your_api_key"
+export CLOUDMCP_CLIENT_PROFILE_ID="client_profile.codex.default"
+node index.js
 ```
 
-### 方法 2: 手动配置
-
-1. 在 Cursor 配置文件中添加：
-
-**~/.cursor/mcp.json** (macOS/Linux)  
-**%APPDATA%\Cursor\mcp.json** (Windows)
+正式 IDE 安装默认不会把仓库内 `index.js` 路径写进用户配置，而是写入已发布包入口：
 
 ```json
 {
-  "mcpServers": {
-    "cloudflare-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@cloudflare-mcp/smart-proxy"],
-      "env": {
-        "CLOUDFLARE_MCP_URL": "https://your-worker.workers.dev",
-        "CLOUDFLARE_MCP_API_KEY": "your_api_key_here",
-        "WORKSPACE_ROOT": "/path/to/your/workspace"
-      }
-    }
-  }
+  "command": "npx",
+  "args": ["-y", "-p", "cloudflare-mcp-smart-proxy", "cloudflare-mcp-proxy"]
 }
 ```
 
-2. 重启 Cursor IDE
-
-## 环境变量
-
-| 变量名 | 必需 | 说明 |
-|--------|------|------|
-| `CLOUDFLARE_MCP_URL` | ✅ | Cloudflare MCP 服务器 URL |
-| `CLOUDFLARE_MCP_API_KEY` | ✅ | API Key |
-| `WORKSPACE_ROOT` | ❌ | 工作目录根路径（默认: 当前目录） |
+当前已发布包名与可执行名不同，因此正式入口需要显式指定包与命令。仓库内入口只保留给本地开发调试，通过 `--runtime local` 显式选择。
 
-## 使用示例
+### 2. 作为参考连接器安装器运行
 
-### 读取本地文件
-
-```json
-{
-  "tool": "read_file",
-  "params": {
-    "target_file": "src/index.js",
-    "offset": 0,
-    "limit": 50
-  }
-}
+```bash
+cd /home/coder/project/CLOUDMCP/local-proxy
+node connector-cli.js install codex \
+  --cloud-url https://your-cloudmcp.example.com \
+  --api-key your_api_key \
+  --client-profile-id client_profile.codex.default
 ```
 
-### 差异编辑文件
-
-```json
-{
-  "tool": "edit_file",
-  "params": {
-    "path": "src/index.js",
-    "edits": [
-      {
-        "type": "replace",
-        "startLine": 10,
-        "endLine": 12,
-        "oldText": "const x = 1;\nconst y = 2;",
-        "newText": "const x = 1;\nconst y = 3;\nconst z = 4;"
-      }
-    ],
-    "originalContent": "..."
-  }
-}
+```bash
+cd /home/coder/project/CLOUDMCP/local-proxy
+node connector-cli.js install claude_code \
+  --scope project \
+  --cloud-url https://your-cloudmcp.example.com \
+  --api-key your_api_key \
+  --client-profile-id client_profile.claude_code.default
 ```
 
-### 执行本地命令
+## 目标配置文件
 
-```json
-{
-  "tool": "execute_command",
-  "params": {
-    "command": "npm test",
-    "cwd": "."
-  }
-}
-```
+### Codex
 
-## 安全特性
+- 配置文件：`~/.codex/config.toml`
+- 写入方式：managed block，不覆盖用户其他配置
 
-- ✅ 路径验证：防止路径遍历攻击
-- ✅ 工作目录限制：只能访问指定目录内的文件
-- ✅ 命令黑名单：禁止执行危险命令
-- ✅ 超时保护：命令执行 30 秒超时
+### Claude Code
 
-## 故障排除
+- 项目级：`<workspace>/.mcp.json`
+- 用户级：`~/.claude.json`
+- 写入方式：JSON merge，不覆盖其他 `mcpServers`
 
-### 问题 1: 无法连接到云端服务器
+## 默认注入环境变量
 
-**检查**:
-1. 确认 `CLOUDFLARE_MCP_URL` 正确
-2. 确认 `CLOUDFLARE_MCP_API_KEY` 有效
-3. 检查网络连接
+- `CLOUDFLARE_MCP_URL`
+- `CLOUDFLARE_MCP_API_KEY`
+- `WORKSPACE_ROOT`
+- `CLOUDMCP_CLIENT_PROFILE_ID`
+- `CLOUDMCP_CONNECTOR_ID`
+- `CLOUDMCP_CONNECTOR_TYPE`
+- `CLOUDMCP_WORKSPACE_ID`
 
-### 问题 2: 本地文件操作失败
+这些字段会让连接器启动后直接进入：
 
-**检查**:
-1. 确认文件路径在工作目录内
-2. 检查文件权限
-3. 确认路径不包含 `..`
+- `PUT /connectors/workspace-binding`
+- `GET /connectors/install-plan`
+- `POST /connectors/status-reports`
+- `POST /connectors/project-probes`
 
-### 问题 3: Cursor 无法识别服务器
+对应的正式协议定义见：
 
-**检查**:
-1. 重启 Cursor IDE
-2. 检查配置文件 JSON 格式
-3. 查看 Cursor 开发者工具中的错误日志
+- [CLOUDMCP_A2_EXTERNAL_CONNECTOR_CONTRACT_STANDARD_2026-03-30.md](/home/coder/project/CLOUDMCP/docs/CLOUDMCP_A2_EXTERNAL_CONNECTOR_CONTRACT_STANDARD_2026-03-30.md)
+- [CLOUDMCP_A3_OFFICIAL_REFERENCE_CONNECTOR_STANDARD_2026-03-30.md](/home/coder/project/CLOUDMCP/docs/CLOUDMCP_A3_OFFICIAL_REFERENCE_CONNECTOR_STANDARD_2026-03-30.md)
 
-## 开发
+## 常用命令
 
-### 本地测试
+### Dry-run 渲染配置
 
 ```bash
-cd local-proxy
-npm install
-export CLOUDFLARE_MCP_URL="https://your-worker.workers.dev"
-export CLOUDFLARE_MCP_API_KEY="your_key"
-export WORKSPACE_ROOT="/path/to/workspace"
-node index.js
+node connector-cli.js print codex \
+  --cloud-url https://cloudmcp.example.com \
+  --api-key test-key \
+  --client-profile-id client_profile.codex.default
 ```
 
-### 发布到 npm
+### 本地 smoke
 
 ```bash
-npm login
-npm publish --access public
+npm run smoke:connectors
 ```
 
-## 许可证
+## 验证
 
-MIT
-
-## 相关链接
+```bash
+node --test /home/coder/project/CLOUDMCP/tests/reference-connector-a3.test.js
+```
 
-- [Cloudflare MCP 主项目](../README.md)
-- [MCP 协议文档](https://modelcontextprotocol.io/)
+## 备注
 
+- 旧的 Cursor / Claude Desktop 入口仍保留兼容，但它们不再是 A3 主线。
+- A3 没有把 `systemPrompt` 直接写进项目根级 `AGENTS.md` 或 `CLAUDE.md`，以避免覆盖用户已有 agent 规范文件。

package/connector-cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { installReferenceConnector, printReferenceConnectorConfig } from './src/reference-connectors.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function printUsage() {
+  console.error('Usage: cloudmcp-connector <install|print|smoke> <codex|claude_code> [options]');
+  console.error('');
+  console.error('Required options:');
+  console.error('  --cloud-url <url>');
+  console.error('  --api-key <key>');
+  console.error('  --client-profile-id <id>');
+  console.error('');
+  console.error('Optional options:');
+  console.error('  --workspace-root <path>    Default: current directory');
+  console.error('  --workspace-id <id>');
+  console.error('  --connector-id <id>');
+  console.error('  --connector-type <type>    Default: ecosystem name');
+  console.error('  --scope <user|project>     Claude Code supports user/project; Codex is always user');
+  console.error('  --server-name <name>       Default: cloudmcp');
+  console.error('  --runtime <npm|local>      Default: npm');
+  console.error('  --dry-run                  Show output without writing');
+}
+
+function parseArgs(argv) {
+  const [command = '', ecosystem = '', ...rest] = argv;
+  const options = {
+    command,
+    ecosystem
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (!token.startsWith('--')) {
+      throw new Error(`Unexpected argument "${token}"`);
+    }
+
+    const key = token.slice(2);
+    if (key === 'dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    const value = rest[index + 1];
+    if (value == null || value.startsWith('--')) {
+      throw new Error(`Missing value for --${key}`);
+    }
+    options[key] = value;
+    index += 1;
+  }
+
+  return options;
+}
+
+function resolveRequiredOption(options, flagName, envNames = []) {
+  const directValue = options[flagName];
+  if (directValue) return directValue;
+  for (const envName of envNames) {
+    if (process.env[envName]) return process.env[envName];
+  }
+  throw new Error(`Missing required option --${flagName}`);
+}
+
+function buildInstallOptions(options) {
+  const workspaceRoot = path.resolve(options['workspace-root'] || process.cwd());
+  return {
+    ecosystem: options.ecosystem,
+    cloudUrl: resolveRequiredOption(options, 'cloud-url', ['CLOUDFLARE_MCP_URL', 'MCP_URL']),
+    cloudApiKey: resolveRequiredOption(options, 'api-key', ['CLOUDFLARE_MCP_API_KEY', 'MCP_API_KEY']),
+    clientProfileId: resolveRequiredOption(options, 'client-profile-id', ['CLOUDMCP_CLIENT_PROFILE_ID', 'CLIENT_PROFILE_ID']),
+    workspaceRoot,
+    workspaceId: options['workspace-id'] || process.env.CLOUDMCP_WORKSPACE_ID || process.env.WORKSPACE_ID || '',
+    connectorId: options['connector-id'] || process.env.CLOUDMCP_CONNECTOR_ID || process.env.CONNECTOR_ID || '',
+    connectorType: options['connector-type'] || process.env.CLOUDMCP_CONNECTOR_TYPE || process.env.CONNECTOR_TYPE || '',
+    scope: options.scope || 'user',
+    serverName: options['server-name'] || 'cloudmcp',
+    runtime: options.runtime || 'npm',
+    packageRoot: __dirname,
+    dryRun: options.dryRun === true
+  };
+}
+
+function printInstallResult(result, { includeContent = false } = {}) {
+  console.error(`ecosystem: ${result.ecosystem}`);
+  console.error(`scope: ${result.scope}`);
+  console.error(`target: ${result.targetFile}`);
+  console.error(`server: ${result.serverName}`);
+  console.error(`written: ${result.written ? 'yes' : 'no'}`);
+  if (includeContent) {
+    process.stdout.write(`${result.renderedContent}\n`);
+  }
+}
+
+async function runSmoke(ecosystem, options) {
+  const result = printReferenceConnectorConfig({
+    ...buildInstallOptions(options),
+    ecosystem
+  });
+  if (!result.renderedContent.includes(result.serverName)) {
+    throw new Error(`Smoke failed: missing server name in rendered content for ${ecosystem}`);
+  }
+  if (!result.renderedContent.includes('CLOUDMCP_CLIENT_PROFILE_ID')) {
+    throw new Error(`Smoke failed: missing connector env in rendered content for ${ecosystem}`);
+  }
+  printInstallResult(result, { includeContent: true });
+}
+
+async function main() {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+
+    if (!['install', 'print', 'smoke'].includes(options.command)) {
+      printUsage();
+      process.exit(1);
+    }
+    if (!['codex', 'claude_code'].includes(options.ecosystem)) {
+      printUsage();
+      process.exit(1);
+    }
+
+    if (options.command === 'install') {
+      const result = installReferenceConnector(buildInstallOptions(options));
+      printInstallResult(result);
+      return;
+    }
+
+    if (options.command === 'print') {
+      const result = printReferenceConnectorConfig(buildInstallOptions(options));
+      printInstallResult(result, { includeContent: true });
+      return;
+    }
+
+    await runSmoke(options.ecosystem, options);
+  } catch (error) {
+    console.error(`cloudmcp-connector error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/index.js

@@ -15,11 +15,20 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 import { SmartRouter } from './src/router.js';
 import { LocalToolExecutor } from './src/local-tools.js';
+import { ConnectorBridge } from './src/connector-bridge.js';
 
 // 从环境变量读取配置
 const CLOUD_URL = process.env.CLOUDFLARE_MCP_URL || process.env.MCP_URL;
 const CLOUD_API_KEY = process.env.CLOUDFLARE_MCP_API_KEY || process.env.MCP_API_KEY;
 const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || process.cwd();
+const CLIENT_PROFILE_ID = process.env.CLOUDMCP_CLIENT_PROFILE_ID || process.env.CLIENT_PROFILE_ID || '';
+const CONNECTOR_ID = process.env.CLOUDMCP_CONNECTOR_ID || process.env.CONNECTOR_ID || '';
+const CONNECTOR_TYPE = process.env.CLOUDMCP_CONNECTOR_TYPE || process.env.CONNECTOR_TYPE || 'smart_proxy';
+const WORKSPACE_ID = process.env.CLOUDMCP_WORKSPACE_ID || process.env.WORKSPACE_ID || '';
+const AUTO_SYNC_PROFILE = (process.env.CLOUDMCP_AUTO_SYNC_PROFILE || 'true') !== 'false';
+const AUTO_APPLY_BRAIN = (process.env.CLOUDMCP_AUTO_APPLY_BRAIN || 'true') !== 'false';
+const AUTO_REPORT_PROJECT_PROBE = (process.env.CLOUDMCP_AUTO_REPORT_PROJECT_PROBE || 'true') === 'true';
+const AUTO_GENERATE_CONTEXT_PACK = (process.env.CLOUDMCP_AUTO_GENERATE_CONTEXT_PACK || 'true') === 'true';
 
 if (!CLOUD_URL || !CLOUD_API_KEY) {
   console.error('Error: CLOUDFLARE_MCP_URL and CLOUDFLARE_MCP_API_KEY environment variables are required');
@@ -31,8 +40,17 @@ if (!CLOUD_URL || !CLOUD_API_KEY) {
 }
 
 // 初始化组件
-const localTools = new LocalToolExecutor(WORKSPACE_ROOT);
-const router = new SmartRouter(CLOUD_URL, CLOUD_API_KEY, localTools, WORKSPACE_ROOT);
+const connectorBridge = new ConnectorBridge({
+  cloudUrl: CLOUD_URL,
+  cloudApiKey: CLOUD_API_KEY,
+  workspaceRoot: WORKSPACE_ROOT,
+  clientProfileId: CLIENT_PROFILE_ID,
+  connectorId: CONNECTOR_ID,
+  connectorType: CONNECTOR_TYPE,
+  workspaceId: WORKSPACE_ID
+});
+const localTools = new LocalToolExecutor(WORKSPACE_ROOT, connectorBridge);
+const router = new SmartRouter(CLOUD_URL, CLOUD_API_KEY, localTools, WORKSPACE_ROOT, connectorBridge.deviceIdentity);
 
 // 创建 MCP 服务器
 const server = new Server(
@@ -196,6 +214,23 @@ async function main() {
     console.error('Cloudflare MCP Smart Proxy started');
     console.error(`Workspace root: ${WORKSPACE_ROOT}`);
     console.error(`Cloud URL: ${CLOUD_URL}`);
+    if (connectorBridge.isConfigured()) {
+      const bridgeStatus = await connectorBridge.initialize({
+        autoApplyBrain: AUTO_APPLY_BRAIN,
+        autoSyncProfile: AUTO_SYNC_PROFILE,
+        autoReportProjectProbe: AUTO_REPORT_PROJECT_PROBE,
+        autoGenerateContextPack: AUTO_GENERATE_CONTEXT_PACK
+      });
+      console.error(`Connector bridge profile: ${bridgeStatus.clientProfileId}`);
+      console.error(`Connector bridge workspace: ${bridgeStatus.workspaceId}`);
+      const applyResult = bridgeStatus.state?.lastBrainApplyResult;
+      if (applyResult) {
+        console.error(`Brain applied for IDE: ${applyResult.ide} (${applyResult.applied?.length || 0} files written)`);
+      }
+      console.error(`Connector bridge auto probe: ${AUTO_REPORT_PROJECT_PROBE ? 'enabled' : 'disabled'}`);
+    } else {
+      console.error('Connector bridge profile: not configured');
+    }
   } catch (error) {
     console.error('Failed to start server:', error);
     process.exit(1);
@@ -206,4 +241,3 @@ main().catch((error) => {
   console.error('Fatal error:', error);
   process.exit(1);
 });
-

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
   "type": "module",
+  "packageManager": "pnpm@10.33.0",
   "main": "index.js",
   "bin": {
-    "cloudflare-mcp-proxy": "./index.js"
+    "cloudflare-mcp-smart-proxy": "./index.js",
+    "cloudflare-mcp-proxy": "./index.js",
+    "cloudmcp-connector": "./connector-cli.js"
   },
   "scripts": {
-    "start": "node index.js"
+    "start": "node index.js",
+    "smoke:connectors": "node connector-cli.js smoke codex --cloud-url https://cloudmcp.example.com --api-key test-key --client-profile-id client_profile.codex.default && node connector-cli.js smoke claude_code --cloud-url https://cloudmcp.example.com --api-key test-key --client-profile-id client_profile.claude_code.default --scope project"
   },
   "keywords": [
     "mcp",

package/src/cloud-client.js

@@ -0,0 +1,135 @@
+const CONNECTOR_CONTRACT_VERSION = 'a2.v1';
+
+export class CloudClient {
+  constructor({ cloudUrl, cloudApiKey, deviceIdentity = null }) {
+    this.cloudUrl = String(cloudUrl || '').replace(/\/$/, '');
+    this.cloudApiKey = cloudApiKey || '';
+    this.deviceIdentity = deviceIdentity;
+    if (!this.cloudUrl) {
+      throw new Error('cloudUrl is required');
+    }
+    if (!this.cloudApiKey) {
+      throw new Error('cloudApiKey is required');
+    }
+  }
+
+  buildUrl(path, query = null) {
+    const url = new URL(path, `${this.cloudUrl}/`);
+    if (query && typeof query === 'object') {
+      Object.entries(query).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+
+  async request(path, { method = 'GET', body, query, idempotencyKey } = {}) {
+    const serializedBody = body == null ? '' : JSON.stringify(body);
+    const signedHeaders = this.deviceIdentity
+      ? await this.deviceIdentity.buildSignedHeaders({
+          method,
+          pathname: new URL(this.buildUrl(path, query)).pathname,
+          body: serializedBody
+        })
+      : {};
+    const response = await fetch(this.buildUrl(path, query), {
+      method,
+      headers: {
+        'Authorization': `Bearer ${this.cloudApiKey}`,
+        'Content-Type': 'application/json',
+        'X-CloudMCP-Connector-Contract-Version': CONNECTOR_CONTRACT_VERSION,
+        ...signedHeaders,
+        ...(idempotencyKey ? { 'X-Idempotency-Key': idempotencyKey } : {})
+      },
+      body: body == null ? undefined : serializedBody
+    });
+
+    let data = null;
+    try {
+      data = await response.json();
+    } catch {
+      data = null;
+    }
+
+    if (!response.ok) {
+      const message = data?.error?.message || data?.error || `${response.status} ${response.statusText}`;
+      throw new Error(message);
+    }
+
+    if (data?.connectorContractVersion && data.connectorContractVersion !== CONNECTOR_CONTRACT_VERSION) {
+      throw new Error(`Unsupported connector contract version "${data.connectorContractVersion}"`);
+    }
+
+    return data;
+  }
+
+  async fetchInstallPlan({ clientProfileId, workspaceId }) {
+    return this.request('/connectors/install-plan', {
+      query: { clientProfileId, workspaceId }
+    });
+  }
+
+  async listConnectorStatusReports({ clientProfileId, workspaceId, connectorId, limit = 5 }) {
+    return this.request('/connectors/status-reports', {
+      query: { clientProfileId, workspaceId, connectorId, limit }
+    });
+  }
+
+  async createConnectorStatusReport({ clientProfileId, report }) {
+    return this.request('/connectors/status-reports', {
+      method: 'POST',
+      idempotencyKey: report.idempotencyKey,
+      body: {
+        ...report,
+        clientProfileId
+      }
+    });
+  }
+
+  async fetchWorkspaceGrant({ clientProfileId, workspaceId, connectorId }) {
+    return this.request('/connectors/workspace-binding', {
+      query: { clientProfileId, workspaceId, connectorId }
+    });
+  }
+
+  async listProjectProbes({ clientProfileId, workspaceId, connectorId, status }) {
+    return this.request('/connectors/project-probes', {
+      query: { clientProfileId, workspaceId, connectorId, status }
+    });
+  }
+
+  async createProjectProbe({ clientProfileId, probe, autoGenerateContextPack = false }) {
+    return this.request('/connectors/project-probes', {
+      method: 'POST',
+      idempotencyKey: probe.idempotencyKey,
+      query: autoGenerateContextPack ? { auto_generate_context_pack: 'true', clientProfileId } : { clientProfileId },
+      body: {
+        ...probe,
+        clientProfileId
+      }
+    });
+  }
+
+  async fetchBrainSnapshot({ clientProfileId, workspaceId }) {
+    return this.request(`/admin/client-profiles/${encodeURIComponent(clientProfileId)}/brain-snapshot`, {
+      query: { workspaceId }
+    });
+  }
+
+  async getConnectorContract() {
+    return this.request('/connectors/contract');
+  }
+
+  async registerDevice(payload) {
+    return this.request('/connectors/device/register', {
+      method: 'POST',
+      body: payload
+    });
+  }
+
+  async getCurrentDevice() {
+    return this.request('/connectors/device/current');
+  }
+}