@kln-mcp/ctrl-mobile-cn 0.0.6

package/bin/install.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const packageRoot = path.resolve(__dirname, '..');
+const packageJson = require(path.join(packageRoot, 'package.json'));
+const PACKAGE_NAME = packageJson.name;
+const PACKAGE_VERSION = packageJson.version;
+const LANG = PACKAGE_NAME.endsWith('-cn') ? 'cn' : 'en';
+const MCP_SERVER_NAME = 'kln-ctrl-mobile';
+const DEFAULT_API_BASE = readDefaultApiBase();
+
+function readDefaultApiBase() {
+  const file = path.join(packageRoot, 'config', 'pro.json');
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (data && typeof data.api_url === 'string' && data.api_url.trim()) {
+      return data.api_url.trim();
+    }
+    fail('config/pro.json missing api_url');
+  } catch (e) {
+    fail(`failed to read config/pro.json: ${e.message}`);
+  }
+}
+
+const T = LANG === 'cn' ? {
+  missingToken: '缺少 --token (也可通过环境变量 KLN_INSTALL_TOKEN 传入)',
+  installing: '正在为 OpenClaw 安装 kln-ctrl-mobile MCP...',
+  exchangeFail: '安装命令无效或已失效',
+  installFail: '安装失败',
+  openclawMissing: '未找到 openclaw 命令,请先安装 OpenClaw (npm i -g openclaw)',
+  mcpSetFail: '调用 openclaw mcp set 失败',
+  done: '安装完成',
+  mcpServer: 'MCP 服务',
+  installPath: '安装目录',
+  skillFile: 'Skill 文件',
+  registered: '已通过 openclaw mcp set 注册',
+  reloadHint: '请重启或重新加载 OpenClaw 让配置生效。',
+  dryRun: '[dry-run] 跳过实际写文件'
+} : {
+  missingToken: 'missing --token (or set KLN_INSTALL_TOKEN env var)',
+  installing: 'Installing kln-ctrl-mobile MCP for OpenClaw...',
+  exchangeFail: 'install token is invalid or has expired',
+  installFail: 'installation failed',
+  openclawMissing: 'openclaw command not found; install it first (npm i -g openclaw)',
+  mcpSetFail: 'openclaw mcp set failed',
+  done: 'install complete',
+  mcpServer: 'MCP server',
+  installPath: 'install dir',
+  skillFile: 'skill',
+  registered: 'registered via `openclaw mcp set`',
+  reloadHint: 'Please restart or reload OpenClaw to pick up the new MCP server.',
+  dryRun: '[dry-run] skipping file writes'
+};
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (!opts.token) fail(T.missingToken);
+
+  const apiBase = opts.apiBase || process.env.KLN_API_BASE_URL || DEFAULT_API_BASE;
+  const installDir = path.resolve(
+    opts.installDir
+      || process.env.KLN_INSTALL_DIR
+      || path.join(os.homedir(), '.kln', 'ctrl-mobile', PACKAGE_VERSION)
+  );
+  const skillsDir = path.resolve(
+    opts.skillsDir || process.env.KLN_OPENCLAW_SKILLS_DIR || detectSkillsDir()
+  );
+
+  process.stdout.write(`${T.installing}\n`);
+
+  let apiKey;
+  if (opts.apiKey) {
+    apiKey = opts.apiKey;
+  } else {
+    try {
+      apiKey = await exchangeToken({ apiBase, token: opts.token });
+    } catch (e) {
+      await safePostResult({ apiBase, token: opts.token, status: 'failed', error: `exchange: ${e.message}`, installDir });
+      fail(`${T.exchangeFail}: ${e.message}`);
+    }
+  }
+
+  if (opts.dryRun) {
+    process.stdout.write(`${T.dryRun}\n`);
+    process.stdout.write(`  ${T.installPath}: ${installDir}\n`);
+    process.stdout.write(`  ${T.mcpServer}: ${MCP_SERVER_NAME} (openclaw mcp set)\n`);
+    process.stdout.write(`  ${T.skillFile}: ${path.join(skillsDir, 'kln-mobile-ctrl/SKILL.md')}\n`);
+    return;
+  }
+
+  try {
+    copyPackageTo(installDir);
+    copyPlatformBinary(installDir);
+    verifyNativeLoad(installDir);
+    runOpenclawMcpSet({ installDir, apiKey });
+    copySkillFile({ installDir, skillsDir });
+  } catch (e) {
+    await safePostResult({ apiBase, token: opts.token, status: 'failed', error: `install: ${e.message}`, installDir });
+    fail(`${T.installFail}: ${e.message}`);
+  }
+
+  await safePostResult({ apiBase, token: opts.token, status: 'success', installDir });
+
+  process.stdout.write(`${T.done}\n`);
+  process.stdout.write(`  ${T.installPath}: ${installDir}\n`);
+  process.stdout.write(`  ${T.mcpServer}: ${MCP_SERVER_NAME} (${T.registered})\n`);
+  process.stdout.write(`  ${T.skillFile}: ${path.join(skillsDir, 'kln-mobile-ctrl/SKILL.md')}\n`);
+  process.stdout.write(`${T.reloadHint}\n`);
+}
+
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') { printHelp(); process.exit(0); }
+    if (arg === '--dry-run') { opts.dryRun = true; continue; }
+    if (!arg.startsWith('--')) fail(`unknown argument: ${arg}`);
+    const eq = arg.indexOf('=');
+    const key = eq >= 0 ? arg.slice(2, eq) : arg.slice(2);
+    const val = eq >= 0 ? arg.slice(eq + 1) : argv[++i];
+    if (val === undefined || (typeof val === 'string' && val.startsWith('--'))) {
+      fail(`missing value for --${key}`);
+    }
+    if (key === 'token') opts.token = val;
+    else if (key === 'api-base') opts.apiBase = val;
+    else if (key === 'api-key') opts.apiKey = val;
+    else if (key === 'install-dir') opts.installDir = val;
+    else if (key === 'skills-dir') opts.skillsDir = val;
+    else fail(`unknown argument: --${key}`);
+  }
+  if (!opts.token) opts.token = process.env.KLN_INSTALL_TOKEN || '';
+  return opts;
+}
+
+function detectSkillsDir() {
+  const home = os.homedir();
+  if (fs.existsSync(path.join(home, '.openclaw'))) return path.join(home, '.openclaw', 'skills');
+  if (fs.existsSync(path.join(home, '.config', 'openclaw'))) return path.join(home, '.config', 'openclaw', 'skills');
+  return path.join(home, '.openclaw', 'skills');
+}
+
+function copyPackageTo(installDir) {
+  fs.rmSync(installDir, { recursive: true, force: true });
+  fs.mkdirSync(installDir, { recursive: true });
+  fs.cpSync(packageRoot, installDir, { recursive: true });
+}
+
+function detectTriple() {
+  const { platform, arch } = process;
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64';
+  if (platform === 'darwin' && arch === 'x64')   return 'darwin-x64';
+  if (platform === 'linux'  && arch === 'x64')   return 'linux-x64-gnu';
+  if (platform === 'linux'  && arch === 'arm64') return 'linux-arm64-gnu';
+  if (platform === 'win32'  && arch === 'x64')   return 'win32-x64-msvc';
+  return null;
+}
+
+function copyPlatformBinary(installDir) {
+  const triple = detectTriple();
+  if (!triple) {
+    throw new Error(
+      `unsupported platform: ${process.platform}-${process.arch}. ` +
+      `Supported: darwin-arm64, darwin-x64, linux-x64-gnu, linux-arm64-gnu, win32-x64-msvc.`
+    );
+  }
+  const subPkg = `@kln-ctrl/mobile-core-${triple}`;
+  let src;
+  try {
+    src = require.resolve(subPkg);
+  } catch (e) {
+    throw new Error(
+      `native binary for ${triple} not installed (missing ${subPkg}). ` +
+      `Reinstall with --include=optional, or your platform may not be supported.`
+    );
+  }
+  const dst = path.join(installDir, 'core', `kln_ctrl_core.${triple}.node`);
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+}
+
+function verifyNativeLoad(installDir) {
+  const corePath = path.join(installDir, 'core');
+  try {
+    require(corePath);
+  } catch (e) {
+    throw new Error(`native binary failed to load: ${e.message}`);
+  }
+}
+
+function runOpenclawMcpSet({ installDir, apiKey }) {
+  const spec = {
+    command: 'node',
+    args: [path.join(installDir, 'index.js'), 'mcp-server', '--env', 'pro'],
+    env: { KLN_API_KEY: apiKey }
+  };
+  const r = spawnSync('openclaw', ['mcp', 'set', MCP_SERVER_NAME, JSON.stringify(spec)], {
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (r.error) {
+    if (r.error.code === 'ENOENT') {
+      throw new Error(T.openclawMissing);
+    }
+    throw new Error(`openclaw spawn failed: ${r.error.message}`);
+  }
+  if (r.status !== 0) {
+    const out = ((r.stderr && r.stderr.toString()) || (r.stdout && r.stdout.toString()) || '').trim();
+    throw new Error(`${T.mcpSetFail}: ${out || `exit ${r.status}`}`);
+  }
+}
+
+function copySkillFile({ installDir, skillsDir }) {
+  const src = path.join(installDir, 'skills', 'kln-mobile-ctrl', 'SKILL.md');
+  if (!fs.existsSync(src)) return;
+  const dst = path.join(skillsDir, 'kln-mobile-ctrl', 'SKILL.md');
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  fs.copyFileSync(src, dst);
+}
+
+async function exchangeToken({ apiBase, token }) {
+  const payload = { install_token: token, system_info: collectSystemInfo() };
+  const data = await postJson(`${apiBase}/api/v1/user/install-token/exchange`, payload);
+  if (!data || data.code !== 0 || !data.data || !data.data.apikey) {
+    throw new Error('invalid response');
+  }
+  return data.data.apikey;
+}
+
+async function safePostResult({ apiBase, token, status, error = '', installDir }) {
+  const payload = {
+    install_token: token,
+    status,
+    agent: 'openclaw',
+    fingerprint: fingerprint(),
+    install_dir: installDir || '',
+    package_version: PACKAGE_VERSION,
+    system_info: collectSystemInfo(),
+    error: error || ''
+  };
+  try {
+    await postJson(`${apiBase}/api/v1/user/install-token/install-result`, payload);
+  } catch (_) {}
+}
+
+function collectSystemInfo() {
+  return {
+    agent: 'openclaw',
+    platform: os.platform(),
+    arch: os.arch(),
+    release: os.release(),
+    hostname: os.hostname(),
+    node: process.version
+  };
+}
+
+function fingerprint() {
+  const raw = [os.platform(), os.arch(), os.release(), os.hostname(), os.homedir()].join('|');
+  return crypto.createHash('sha256').update(raw).digest('hex');
+}
+
+async function postJson(url, payload) {
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  });
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+  return resp.json();
+}
+
+function printHelp() {
+  const help = LANG === 'cn' ? `
+用法: npx -y ${PACKAGE_NAME}@latest --token <install-token>
+
+选项:
+  --token <token>         安装 token (必须;也可通过 KLN_INSTALL_TOKEN 环境变量)
+  --api-base <url>        后端 API base URL (默认 ${DEFAULT_API_BASE})
+  --install-dir <path>    安装目录 (默认 ~/.kln/ctrl-mobile/<version>)
+  --skills-dir <path>     openclaw skills 目录 (默认自动检测)
+  --dry-run               只打印计划,不实际修改文件
+  --help, -h              显示此帮助
+
+说明:
+  MCP 配置通过 \`openclaw mcp set ${MCP_SERVER_NAME} <spec>\` 注册,不直接编辑 openclaw.json。
+  安装后用 \`openclaw mcp list\` 可以验证。
+` : `
+Usage: npx -y ${PACKAGE_NAME}@latest --token <install-token>
+
+Options:
+  --token <token>         install token (required; or set KLN_INSTALL_TOKEN)
+  --api-base <url>        backend API base URL (default ${DEFAULT_API_BASE})
+  --install-dir <path>    install destination (default ~/.kln/ctrl-mobile/<version>)
+  --skills-dir <path>     openclaw skills dir (auto-detected by default)
+  --dry-run               print plan only; do not modify files
+  --help, -h              show this help
+
+Notes:
+  MCP server is registered via \`openclaw mcp set ${MCP_SERVER_NAME} <spec>\`,
+  not by editing openclaw.json directly. Verify with \`openclaw mcp list\` afterwards.
+`;
+  process.stdout.write(help);
+}
+
+function fail(msg) {
+  process.stderr.write(`install: ${msg}\n`);
+  process.exit(1);
+}
+
+main().catch((e) => fail(e && e.message ? e.message : String(e)));

package/cli/setup.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const { createController, createMcpServer, TOOL_DEFINITIONS, checkTaskMemoryFile } = require('../wrapper');
+const { loadConfig } = require('../config');
+
+const COMMANDS = new Set(['help', 'mcp-server', 'mcp', 'devices', 'select-device', 'command', 'text', 'send-only', 'device-context', 'memory', 'doctor', 'stream', 'view', 'config', 'tools']);
+
+async function run(argv = process.argv.slice(2), io = process) {
+  const parsed = parseArgs(argv);
+  const command = parsed.command || 'help';
+
+  if (command === 'help') {
+    io.stdout.write(helpText());
+    return 0;
+  }
+
+  if (command === 'tools') {
+    io.stdout.write(`${JSON.stringify(TOOL_DEFINITIONS, null, 2)}\n`);
+    return 0;
+  }
+
+  if (command === 'config') {
+    const config = loadConfig(parsed.options.env);
+    writeResult(io, config, parsed.options);
+    return 0;
+  }
+
+  if (command === 'doctor') {
+    const checks = [
+      {
+        name: 'task_memory',
+        ...checkTaskMemoryFile(parsed.options.taskMemoryPath)
+      }
+    ];
+    writeResult(io, {
+      ok: checks.every((check) => check.ok),
+      checks
+    }, parsed.options);
+    return 0;
+  }
+
+  if (command === 'mcp' || command === 'mcp-server') {
+    const server = createMcpServer(toControllerOptions(parsed.options));
+    await server.listenStdio(io.stdin, io.stdout);
+    return 0;
+  }
+
+  const controller = createController(toControllerOptions(parsed.options));
+  try {
+    if (command === 'devices') {
+      const result = await controller.listServerDevices(parsed.options);
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'select-device') {
+      const deviceId = parsed.positionals[0] || parsed.options.deviceId;
+      const result = await controller.selectDevice(deviceId, parsed.options);
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'command') {
+      const name = parsed.positionals[0];
+      const text = collectText(parsed.positionals.slice(1), parsed.options.text);
+      const result = await controller.sendCommand(name, text, parsed.options);
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'text') {
+      const text = collectText(parsed.positionals, parsed.options.text);
+      const result = await controller.sendText(text, parsed.options);
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'send-only') {
+      const name = parsed.positionals[0];
+      const text = collectText(parsed.positionals.slice(1), parsed.options.text);
+      const messageId = await controller.sendOnlyCommand(name, text, parsed.options);
+      writeResult(io, { messageId }, parsed.options);
+      return 0;
+    }
+
+    if (command === 'device-context') {
+      const result = await controller.getDeviceContext(parsed.options);
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'memory') {
+      const result = controller.taskMemory(memoryArgs(parsed.positionals, parsed.options));
+      writeResult(io, result, parsed.options);
+      return 0;
+    }
+
+    if (command === 'stream') {
+      const text = collectText(parsed.positionals, parsed.options.text, true);
+      const file = await controller.startScreenStream(text, parsed.options);
+      writeResult(io, { file }, parsed.options);
+      return 0;
+    }
+
+    if (command === 'view') {
+      const text = collectText(parsed.positionals, parsed.options.text, true);
+      const server = await controller.startLiveView(text, parsed.options);
+      const shutdown = () => {
+        server.close().catch((error) => {
+          io.stderr.write(`${error.message || error}\n`);
+        });
+      };
+      process.once('SIGINT', shutdown);
+      process.once('SIGTERM', shutdown);
+      io.stderr.write(`KLN live view: ${server.url}\n`);
+      await server.wait();
+      return 0;
+    }
+
+    throw new Error(`unknown command: ${command}`);
+  } finally {
+    await controller.close();
+  }
+}
+
+function parseArgs(argv) {
+  const options = {};
+  const positionals = [];
+  let command;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--') {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+
+    if (arg.startsWith('--')) {
+      const eq = arg.indexOf('=');
+      const key = normalizeOptionName(eq === -1 ? arg.slice(2) : arg.slice(2, eq));
+      const value = eq === -1 ? readOptionValue(argv, index + 1, key) : arg.slice(eq + 1);
+      if (eq === -1 && key !== 'json') {
+        index += 1;
+      }
+      setOption(options, key, value);
+      continue;
+    }
+
+    if (!command && COMMANDS.has(arg)) {
+      command = arg;
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return { command, options, positionals };
+}
+
+function readOptionValue(argv, index, key) {
+  if (key === 'json') {
+    return true;
+  }
+
+  const value = argv[index];
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`missing value for --${key}`);
+  }
+  return value;
+}
+
+function setOption(options, key, value) {
+  if (key === 'relayUrls') {
+    options.relayUrls = options.relayUrls || [];
+    options.relayUrls.push(value);
+    return;
+  }
+  options[key] = value;
+}
+
+function normalizeOptionName(name) {
+  switch (name) {
+    case 'relay-url':
+    case 'relay':
+      return 'relayUrls';
+    case 'timeout':
+    case 'timeout-ms':
+      return 'timeoutMs';
+    case 'output':
+    case 'output-dir':
+      return 'outputDir';
+    default:
+      return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+  }
+}
+
+function toControllerOptions(options) {
+  return {
+    ticket: options.ticket,
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    deviceId: options.deviceId,
+    deviceCachePath: options.deviceCachePath,
+    relayUrls: options.relayUrls,
+    alpn: options.alpn,
+    timeoutMs: options.timeoutMs,
+    outputDir: options.outputDir,
+    taskMemoryPath: options.taskMemoryPath,
+    trace_id: options.traceId,
+    env: options.env
+  };
+}
+
+function memoryArgs(positionals, options) {
+  const op = positionals[0] || options.op;
+  const key = options.key || positionals[1];
+  const args = {
+    op,
+    key,
+    value: options.value,
+    summary: options.summary,
+    progress: options.progress
+  };
+  if (op === 'put' && args.value === undefined && positionals.length > 2) {
+    args.value = positionals.slice(2).join(' ');
+  }
+  return args;
+}
+
+function collectText(positionals, explicitText, allowEmpty = false) {
+  if (explicitText !== undefined) {
+    return explicitText;
+  }
+
+  const text = positionals.join(' ');
+  if (!allowEmpty && text.length === 0) {
+    throw new Error('text is required');
+  }
+  return text;
+}
+
+function writeResult(io, result, options) {
+  if (options.json) {
+    io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return;
+  }
+
+  if (result && typeof result === 'object') {
+    if (result.summary) {
+      io.stdout.write(`${result.summary}\n`);
+      return;
+    }
+    if (result.file) {
+      io.stdout.write(`${result.file}\n`);
+      return;
+    }
+  }
+
+  io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+function helpText() {
+  return `kln-mobile-ctrl MCP CLI
+
+Usage:
+  node mcp/index.js mcp-server --env dev --ticket <ticket>
+  node mcp/index.js mcp-server --env dev --api-key <api-key>
+  node mcp/index.js devices --api-key <api-key>
+  node mcp/index.js select-device <device-id> --api-key <api-key>
+  node mcp/index.js command <name> [text] --ticket <ticket>
+  node mcp/index.js text <text> --ticket <ticket>
+  node mcp/index.js send-only <name> [text] --ticket <ticket>
+  node mcp/index.js device-context --ticket <ticket>
+  node mcp/index.js memory list|get|put|delete [key] [value] --summary <text> --progress <text>
+  node mcp/index.js doctor
+  node mcp/index.js stream [text] --output-dir outputs --ticket <ticket>
+  node mcp/index.js view [json-config] --port 8090 --ticket <ticket>
+  node mcp/index.js config [--env dev|pro]
+  node mcp/index.js tools
+
+Options:
+  --ticket <ticket>        P2P endpoint ticket, or set KLN_TICKET.
+  --api-key <key>          KLN server API key, or set KLN_API_KEY.
+  --api-url <url>          KLN server URL, or set KLN_API_URL.
+  --device-id <id>         Server device ID, or use cached selection.
+  --device-cache-path <p>  Selected device cache file.
+  --relay-url <url>        Relay URL. Can be repeated; defaults to mcp/config.
+  --timeout-ms <ms>        Response timeout. Default: 30000.
+  --trace-id <id>          Use a caller-provided trace ID. Generated automatically when omitted.
+  --task-memory-path <p>   Task memory JSON file. Default: ~/.kln/task_memory.json.
+  --output-dir <dir>       Stream output directory. Default: ./outputs.
+  --host <host>            Live view host. Default: 127.0.0.1.
+  --port <port>            Live view port. Default: 8090.
+  --env <dev|pro>          Config environment. Default: KLN_ENV/NODE_ENV/dev.
+  --alpn <value>           Override ALPN.
+  --json                   Print JSON output.
+`;
+}
+
+module.exports = {
+  run,
+  parseArgs,
+  helpText
+};

package/config/index.d.ts

@@ -0,0 +1,19 @@
+export interface KlnMcpConfig {
+  env: 'dev' | 'pro';
+  api_url: string;
+  relay_urls: string[];
+  openobserve: KlnOpenObserveConfig;
+}
+
+export interface KlnOpenObserveConfig {
+  enabled: boolean;
+  upload_url: string;
+  service_name: string;
+  batch_max_records?: number;
+  batch_flush_ms?: number;
+  disk_buffer_dir?: string;
+}
+
+export declare function loadConfig(runtimeEnv?: string): KlnMcpConfig;
+export declare function normalizeEnv(runtimeEnv?: string): 'dev' | 'pro';
+export declare function resolveConfigPath(runtimeEnv?: string): string;