@lobehub/cli 0.0.1-canary.1

package/dist/index.js

@@ -0,0 +1,1170 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/connect.ts
+import os3 from "os";
+import path3 from "path";
+
+// ../../packages/device-gateway-client/src/client.ts
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
+import os from "os";
+import WebSocket from "ws";
+var DEFAULT_GATEWAY_URL = "https://device-gateway.lobehub.com";
+var HEARTBEAT_INTERVAL = 3e4;
+var INITIAL_RECONNECT_DELAY = 1e3;
+var MAX_RECONNECT_DELAY = 3e4;
+var noopLogger = {
+  debug: () => {
+  },
+  error: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  }
+};
+var GatewayClient = class extends EventEmitter {
+  ws = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = INITIAL_RECONNECT_DELAY;
+  status = "disconnected";
+  intentionalDisconnect = false;
+  deviceId;
+  gatewayUrl;
+  token;
+  userId;
+  logger;
+  autoReconnect;
+  constructor(options) {
+    super();
+    this.token = options.token;
+    this.gatewayUrl = options.gatewayUrl || DEFAULT_GATEWAY_URL;
+    this.deviceId = options.deviceId || randomUUID();
+    this.userId = options.userId;
+    this.logger = options.logger || noopLogger;
+    this.autoReconnect = options.autoReconnect ?? true;
+  }
+  // ─── Public API ───
+  get connectionStatus() {
+    return this.status;
+  }
+  get currentDeviceId() {
+    return this.deviceId;
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  async connect() {
+    if (this.status === "connected" || this.status === "connecting") {
+      return;
+    }
+    this.intentionalDisconnect = false;
+    this.doConnect();
+  }
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    this.cleanup();
+    this.setStatus("disconnected");
+  }
+  sendToolCallResponse(response) {
+    this.sendMessage({
+      ...response,
+      type: "tool_call_response"
+    });
+  }
+  sendSystemInfoResponse(response) {
+    this.sendMessage({
+      ...response,
+      type: "system_info_response"
+    });
+  }
+  // ─── Connection Logic ───
+  doConnect() {
+    this.clearReconnectTimer();
+    this.setStatus("connecting");
+    try {
+      const wsUrl = this.buildWsUrl();
+      this.logger.debug(`Connecting to: ${wsUrl}`);
+      const ws = new WebSocket(wsUrl);
+      ws.on("open", this.handleOpen);
+      ws.on("message", this.handleMessage);
+      ws.on("close", this.handleClose);
+      ws.on("error", this.handleError);
+      this.ws = ws;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      this.logger.error("Failed to create WebSocket:", msg);
+      this.setStatus("disconnected");
+      if (this.autoReconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.emit("disconnected");
+      }
+    }
+  }
+  buildWsUrl() {
+    const wsProtocol = this.gatewayUrl.startsWith("https") ? "wss" : "ws";
+    const host = this.gatewayUrl.replace(/^https?:\/\//, "");
+    const params = new URLSearchParams({
+      deviceId: this.deviceId,
+      hostname: os.hostname(),
+      platform: process.platform
+    });
+    if (this.userId) {
+      params.set("userId", this.userId);
+    }
+    return `${wsProtocol}://${host}/ws?${params.toString()}`;
+  }
+  // ─── WebSocket Event Handlers ───
+  handleOpen = () => {
+    this.logger.info("WebSocket connected, sending auth...");
+    this.reconnectDelay = INITIAL_RECONNECT_DELAY;
+    this.setStatus("authenticating");
+    this.sendMessage({ type: "auth", token: this.token });
+  };
+  handleMessage = (data) => {
+    try {
+      const message = JSON.parse(String(data));
+      switch (message.type) {
+        case "auth_success": {
+          this.logger.info("Authentication successful");
+          this.setStatus("connected");
+          this.startHeartbeat();
+          this.emit("connected");
+          break;
+        }
+        case "auth_failed": {
+          const reason = message.reason || "Unknown reason";
+          this.logger.error(`Authentication failed: ${reason}`);
+          this.emit("auth_failed", reason);
+          this.disconnect();
+          break;
+        }
+        case "heartbeat_ack": {
+          this.emit("heartbeat_ack");
+          break;
+        }
+        case "tool_call_request": {
+          this.emit("tool_call_request", message);
+          break;
+        }
+        case "system_info_request": {
+          this.emit("system_info_request", message);
+          break;
+        }
+        case "auth_expired": {
+          this.logger.warn("Received auth_expired from gateway");
+          this.emit("auth_expired");
+          break;
+        }
+        default: {
+          this.logger.warn("Unknown message type:", message.type);
+        }
+      }
+    } catch (error) {
+      this.logger.error("Failed to parse WebSocket message:", error);
+    }
+  };
+  handleClose = (code, reason) => {
+    this.logger.info(`WebSocket closed: code=${code} reason=${reason.toString()}`);
+    this.stopHeartbeat();
+    this.ws = null;
+    if (!this.intentionalDisconnect && this.autoReconnect) {
+      this.setStatus("reconnecting");
+      this.scheduleReconnect();
+    } else {
+      this.setStatus("disconnected");
+      this.emit("disconnected");
+    }
+  };
+  handleError = (error) => {
+    this.logger.error("WebSocket error:", error.message);
+    this.emit("error", error);
+  };
+  // ─── Heartbeat ───
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.sendMessage({ type: "heartbeat" });
+    }, HEARTBEAT_INTERVAL);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  // ─── Reconnection (exponential backoff) ───
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const delay = this.reconnectDelay;
+    this.logger.info(`Scheduling reconnect in ${delay}ms`);
+    this.emit("reconnecting", delay);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.logger.info("Attempting reconnect");
+      this.doConnect();
+    }, delay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // ─── Status ───
+  setStatus(status) {
+    if (this.status === status) return;
+    this.status = status;
+    this.emit("status_changed", status);
+  }
+  // ─── Helpers ───
+  sendMessage(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  closeWebSocket() {
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close(1e3, "Client disconnect");
+      }
+      this.ws = null;
+    }
+  }
+  cleanup() {
+    this.stopHeartbeat();
+    this.clearReconnectTimer();
+    this.closeWebSocket();
+  }
+};
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var verbose = false;
+var setVerbose = (v) => {
+  verbose = v;
+};
+var timestamp = () => {
+  const now = /* @__PURE__ */ new Date();
+  return pc.dim(
+    `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`
+  );
+};
+var log = {
+  debug: (msg, ...args) => {
+    if (verbose) {
+      console.log(`${timestamp()} ${pc.dim("[DEBUG]")} ${msg}`, ...args);
+    }
+  },
+  error: (msg, ...args) => {
+    console.error(`${timestamp()} ${pc.red("[ERROR]")} ${pc.red(msg)}`, ...args);
+  },
+  heartbeat: () => {
+    if (verbose) {
+      process.stdout.write(pc.dim("."));
+    }
+  },
+  info: (msg, ...args) => {
+    console.log(`${timestamp()} ${pc.blue("[INFO]")} ${msg}`, ...args);
+  },
+  status: (status) => {
+    const color = status === "connected" ? pc.green : status === "disconnected" ? pc.red : pc.yellow;
+    console.log(`${timestamp()} ${pc.bold("[STATUS]")} ${color(status)}`);
+  },
+  toolCall: (apiName, requestId, args) => {
+    console.log(
+      `${timestamp()} ${pc.magenta("[TOOL]")} ${pc.bold(apiName)} ${pc.dim(`(${requestId})`)}`
+    );
+    if (args && verbose) {
+      console.log(`  ${pc.dim(args)}`);
+    }
+  },
+  toolResult: (requestId, success, content) => {
+    const icon = success ? pc.green("OK") : pc.red("FAIL");
+    console.log(`${timestamp()} ${pc.magenta("[RESULT]")} ${icon} ${pc.dim(`(${requestId})`)}`);
+    if (content && verbose) {
+      const preview = content.length > 200 ? content.slice(0, 200) + "..." : content;
+      console.log(`  ${pc.dim(preview)}`);
+    }
+  },
+  warn: (msg, ...args) => {
+    console.warn(`${timestamp()} ${pc.yellow("[WARN]")} ${pc.yellow(msg)}`, ...args);
+  }
+};
+
+// src/auth/credentials.ts
+import crypto from "crypto";
+import fs from "fs";
+import os2 from "os";
+import path from "path";
+var CREDENTIALS_DIR = path.join(os2.homedir(), ".lobehub");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function deriveKey() {
+  const material = `lobehub-cli:${os2.hostname()}:${os2.userInfo().username}`;
+  return crypto.pbkdf2Sync(material, "lobehub-cli-salt", 1e5, 32, "sha256");
+}
+function encrypt(plaintext) {
+  const key = deriveKey();
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  const packed = Buffer.concat([iv, authTag, encrypted]);
+  return packed.toString("base64");
+}
+function decrypt(encoded) {
+  const key = deriveKey();
+  const packed = Buffer.from(encoded, "base64");
+  const iv = packed.subarray(0, 12);
+  const authTag = packed.subarray(12, 28);
+  const ciphertext = packed.subarray(28);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  return decipher.update(ciphertext) + decipher.final("utf8");
+}
+function saveCredentials(credentials) {
+  fs.mkdirSync(CREDENTIALS_DIR, { mode: 448, recursive: true });
+  const encrypted = encrypt(JSON.stringify(credentials));
+  fs.writeFileSync(CREDENTIALS_FILE, encrypted, { mode: 384 });
+}
+function loadCredentials() {
+  try {
+    const data = fs.readFileSync(CREDENTIALS_FILE, "utf8");
+    try {
+      const decrypted = decrypt(data);
+      return JSON.parse(decrypted);
+    } catch {
+      const credentials = JSON.parse(data);
+      saveCredentials(credentials);
+      return credentials;
+    }
+  } catch {
+    return null;
+  }
+}
+function clearCredentials() {
+  try {
+    fs.unlinkSync(CREDENTIALS_FILE);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/auth/refresh.ts
+var CLIENT_ID = "lobehub-cli";
+async function getValidToken() {
+  const credentials = loadCredentials();
+  if (!credentials) return null;
+  if (credentials.expiresAt && Date.now() / 1e3 < credentials.expiresAt - 60) {
+    return { credentials };
+  }
+  if (!credentials.refreshToken) return null;
+  const refreshed = await refreshAccessToken(credentials.serverUrl, credentials.refreshToken);
+  if (!refreshed) return null;
+  const updated = {
+    accessToken: refreshed.access_token,
+    expiresAt: refreshed.expires_in ? Math.floor(Date.now() / 1e3) + refreshed.expires_in : void 0,
+    refreshToken: refreshed.refresh_token || credentials.refreshToken,
+    serverUrl: credentials.serverUrl
+  };
+  saveCredentials(updated);
+  return { credentials: updated };
+}
+async function refreshAccessToken(serverUrl, refreshToken) {
+  try {
+    const res = await fetch(`${serverUrl}/oidc/token`, {
+      body: new URLSearchParams({
+        client_id: CLIENT_ID,
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      }),
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      method: "POST"
+    });
+    const body = await res.json();
+    if (!res.ok || body.error || !body.access_token) return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+// src/auth/resolveToken.ts
+function parseJwtSub(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
+    return payload.sub;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveToken(options) {
+  if (options.token) {
+    const userId = parseJwtSub(options.token);
+    if (!userId) {
+      log.error("Could not extract userId from token. Provide --user-id explicitly.");
+      process.exit(1);
+    }
+    return { token: options.token, userId };
+  }
+  if (options.serviceToken) {
+    if (!options.userId) {
+      log.error("--user-id is required when using --service-token");
+      process.exit(1);
+    }
+    return { token: options.serviceToken, userId: options.userId };
+  }
+  const result = await getValidToken();
+  if (result) {
+    log.debug("Using stored credentials");
+    const token = result.credentials.accessToken;
+    const userId = parseJwtSub(token);
+    if (!userId) {
+      log.error("Stored token is invalid. Run 'lh login' again.");
+      process.exit(1);
+    }
+    return { token, userId };
+  }
+  log.error("No authentication found. Run 'lh login' first, or provide --token.");
+  process.exit(1);
+}
+
+// src/tools/file.ts
+import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
+import path2 from "path";
+import { createPatch } from "diff";
+import fg from "fast-glob";
+async function readLocalFile({ path: filePath, loc, fullContent }) {
+  const effectiveLoc = fullContent ? void 0 : loc ?? [0, 200];
+  log.debug(`Reading file: ${filePath}, loc=${JSON.stringify(effectiveLoc)}`);
+  try {
+    const content = await readFile(filePath, "utf8");
+    const lines = content.split("\n");
+    const totalLineCount = lines.length;
+    const totalCharCount = content.length;
+    let selectedContent;
+    let lineCount;
+    let actualLoc;
+    if (effectiveLoc === void 0) {
+      selectedContent = content;
+      lineCount = totalLineCount;
+      actualLoc = [0, totalLineCount];
+    } else {
+      const [startLine, endLine] = effectiveLoc;
+      const selectedLines = lines.slice(startLine, endLine);
+      selectedContent = selectedLines.join("\n");
+      lineCount = selectedLines.length;
+      actualLoc = effectiveLoc;
+    }
+    const fileStat = await stat(filePath);
+    return {
+      charCount: selectedContent.length,
+      content: selectedContent,
+      createdTime: fileStat.birthtime,
+      fileType: path2.extname(filePath).toLowerCase().replace(".", "") || "unknown",
+      filename: path2.basename(filePath),
+      lineCount,
+      loc: actualLoc,
+      modifiedTime: fileStat.mtime,
+      totalCharCount,
+      totalLineCount
+    };
+  } catch (error) {
+    const errorMessage = error.message;
+    return {
+      charCount: 0,
+      content: `Error accessing or processing file: ${errorMessage}`,
+      createdTime: /* @__PURE__ */ new Date(),
+      fileType: path2.extname(filePath).toLowerCase().replace(".", "") || "unknown",
+      filename: path2.basename(filePath),
+      lineCount: 0,
+      loc: [0, 0],
+      modifiedTime: /* @__PURE__ */ new Date(),
+      totalCharCount: 0,
+      totalLineCount: 0
+    };
+  }
+}
+async function writeLocalFile({ path: filePath, content }) {
+  if (!filePath) return { error: "Path cannot be empty", success: false };
+  if (content === void 0) return { error: "Content cannot be empty", success: false };
+  try {
+    const dirname = path2.dirname(filePath);
+    await mkdir(dirname, { recursive: true });
+    await writeFile(filePath, content, "utf8");
+    log.debug(`File written: ${filePath} (${content.length} chars)`);
+    return { success: true };
+  } catch (error) {
+    return { error: `Failed to write file: ${error.message}`, success: false };
+  }
+}
+async function editLocalFile({
+  file_path: filePath,
+  old_string,
+  new_string,
+  replace_all = false
+}) {
+  try {
+    const content = await readFile(filePath, "utf8");
+    if (!content.includes(old_string)) {
+      return {
+        error: "The specified old_string was not found in the file",
+        replacements: 0,
+        success: false
+      };
+    }
+    let newContent;
+    let replacements;
+    if (replace_all) {
+      const regex = new RegExp(old_string.replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&"), "g");
+      const matches = content.match(regex);
+      replacements = matches ? matches.length : 0;
+      newContent = content.replaceAll(old_string, new_string);
+    } else {
+      const index = content.indexOf(old_string);
+      if (index === -1) {
+        return { error: "Old string not found", replacements: 0, success: false };
+      }
+      newContent = content.slice(0, index) + new_string + content.slice(index + old_string.length);
+      replacements = 1;
+    }
+    await writeFile(filePath, newContent, "utf8");
+    const patch = createPatch(filePath, content, newContent, "", "");
+    const diffText = `diff --git a${filePath} b${filePath}
+${patch}`;
+    const patchLines = patch.split("\n");
+    let linesAdded = 0;
+    let linesDeleted = 0;
+    for (const line of patchLines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) linesAdded++;
+      else if (line.startsWith("-") && !line.startsWith("---")) linesDeleted++;
+    }
+    return { diffText, linesAdded, linesDeleted, replacements, success: true };
+  } catch (error) {
+    return { error: error.message, replacements: 0, success: false };
+  }
+}
+async function listLocalFiles({
+  path: dirPath,
+  sortBy = "modifiedTime",
+  sortOrder = "desc",
+  limit = 100
+}) {
+  try {
+    const entries = await readdir(dirPath);
+    const results = [];
+    for (const entry of entries) {
+      const fullPath = path2.join(dirPath, entry);
+      try {
+        const stats = await stat(fullPath);
+        const isDirectory = stats.isDirectory();
+        results.push({
+          createdTime: stats.birthtime,
+          isDirectory,
+          lastAccessTime: stats.atime,
+          modifiedTime: stats.mtime,
+          name: entry,
+          path: fullPath,
+          size: stats.size,
+          type: isDirectory ? "directory" : path2.extname(entry).toLowerCase().replace(".", "")
+        });
+      } catch {
+      }
+    }
+    results.sort((a, b) => {
+      let comparison;
+      switch (sortBy) {
+        case "name": {
+          comparison = (a.name || "").localeCompare(b.name || "");
+          break;
+        }
+        case "modifiedTime": {
+          comparison = a.modifiedTime.getTime() - b.modifiedTime.getTime();
+          break;
+        }
+        case "createdTime": {
+          comparison = a.createdTime.getTime() - b.createdTime.getTime();
+          break;
+        }
+        case "size": {
+          comparison = a.size - b.size;
+          break;
+        }
+        default: {
+          comparison = a.modifiedTime.getTime() - b.modifiedTime.getTime();
+        }
+      }
+      return sortOrder === "desc" ? -comparison : comparison;
+    });
+    const totalCount = results.length;
+    return { files: results.slice(0, limit), totalCount };
+  } catch (error) {
+    log.error(`Failed to list directory ${dirPath}:`, error);
+    return { files: [], totalCount: 0 };
+  }
+}
+async function globLocalFiles({ pattern, cwd }) {
+  try {
+    const files = await fg(pattern, {
+      cwd: cwd || process.cwd(),
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    return { files };
+  } catch (error) {
+    return { error: error.message, files: [] };
+  }
+}
+async function grepContent({ pattern, cwd, filePattern }) {
+  const { spawn: spawn2 } = await import("child_process");
+  return new Promise((resolve) => {
+    const args = ["--json", "-n"];
+    if (filePattern) args.push("--glob", filePattern);
+    args.push(pattern);
+    const child = spawn2("rg", args, { cwd: cwd || process.cwd() });
+    let stdout = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", () => {
+    });
+    child.on("close", (code) => {
+      if (code !== 0 && code !== 1) {
+        log.debug("rg not available, falling back to simple search");
+        resolve({ matches: [], success: false });
+        return;
+      }
+      try {
+        const matches = stdout.split("\n").filter(Boolean).map((line) => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        resolve({ matches, success: true });
+      } catch {
+        resolve({ matches: [], success: true });
+      }
+    });
+    child.on("error", () => {
+      log.debug("rg not available");
+      resolve({ matches: [], success: false });
+    });
+  });
+}
+async function searchLocalFiles({
+  keywords,
+  directory,
+  contentContains,
+  limit = 30
+}) {
+  try {
+    const cwd = directory || process.cwd();
+    const files = await fg(`**/*${keywords}*`, {
+      cwd,
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    let results = files.map((f) => ({ name: path2.basename(f), path: path2.join(cwd, f) }));
+    if (contentContains) {
+      const filtered = [];
+      for (const file of results) {
+        try {
+          const content = await readFile(file.path, "utf8");
+          if (content.includes(contentContains)) {
+            filtered.push(file);
+          }
+        } catch {
+        }
+      }
+      results = filtered;
+    }
+    return results.slice(0, limit);
+  } catch (error) {
+    log.error("File search failed:", error);
+    return [];
+  }
+}
+
+// src/tools/shell.ts
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+var MAX_OUTPUT_LENGTH = 8e4;
+var ANSI_REGEX = (
+  // eslint-disable-next-line no-control-regex
+  /\u001B(?:[\u0040-\u005A\u005C-\u005F]|\[[\u0030-\u003F]*[\u0020-\u002F]*[\u0040-\u007E])/g
+);
+var stripAnsi = (str) => str.replaceAll(ANSI_REGEX, "");
+var truncateOutput = (str, maxLength = MAX_OUTPUT_LENGTH) => {
+  const cleaned = stripAnsi(str);
+  if (cleaned.length <= maxLength) return cleaned;
+  return cleaned.slice(0, maxLength) + "\n... [truncated, " + (cleaned.length - maxLength) + " more characters]";
+};
+var shellProcesses = /* @__PURE__ */ new Map();
+function cleanupAllProcesses() {
+  for (const [id, sp] of shellProcesses) {
+    try {
+      sp.process.kill();
+    } catch {
+    }
+    shellProcesses.delete(id);
+  }
+}
+async function runCommand({
+  command,
+  description,
+  run_in_background,
+  timeout = 12e4
+}) {
+  const logPrefix = `[runCommand: ${description || command.slice(0, 50)}]`;
+  log.debug(`${logPrefix} Starting`, { background: run_in_background, timeout });
+  const effectiveTimeout = Math.min(Math.max(timeout, 1e3), 6e5);
+  const shellConfig = process.platform === "win32" ? { args: ["/c", command], cmd: "cmd.exe" } : { args: ["-c", command], cmd: "/bin/sh" };
+  try {
+    if (run_in_background) {
+      const shellId = randomUUID2();
+      const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+        env: process.env,
+        shell: false
+      });
+      const shellProcess = {
+        lastReadStderr: 0,
+        lastReadStdout: 0,
+        process: childProcess,
+        stderr: [],
+        stdout: []
+      };
+      childProcess.stdout?.on("data", (data) => {
+        shellProcess.stdout.push(data.toString());
+      });
+      childProcess.stderr?.on("data", (data) => {
+        shellProcess.stderr.push(data.toString());
+      });
+      childProcess.on("exit", (code) => {
+        log.debug(`${logPrefix} Background process exited`, { code, shellId });
+      });
+      shellProcesses.set(shellId, shellProcess);
+      log.debug(`${logPrefix} Started background`, { shellId });
+      return { shell_id: shellId, success: true };
+    } else {
+      return new Promise((resolve) => {
+        const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+          env: process.env,
+          shell: false
+        });
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        const timeoutHandle = setTimeout(() => {
+          killed = true;
+          childProcess.kill();
+          resolve({
+            error: `Command timed out after ${effectiveTimeout}ms`,
+            stderr: truncateOutput(stderr),
+            stdout: truncateOutput(stdout),
+            success: false
+          });
+        }, effectiveTimeout);
+        childProcess.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        childProcess.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        childProcess.on("exit", (code) => {
+          if (!killed) {
+            clearTimeout(timeoutHandle);
+            const success = code === 0;
+            resolve({
+              exit_code: code || 0,
+              output: truncateOutput(stdout + stderr),
+              stderr: truncateOutput(stderr),
+              stdout: truncateOutput(stdout),
+              success
+            });
+          }
+        });
+        childProcess.on("error", (error) => {
+          clearTimeout(timeoutHandle);
+          resolve({
+            error: error.message,
+            stderr: truncateOutput(stderr),
+            stdout: truncateOutput(stdout),
+            success: false
+          });
+        });
+      });
+    }
+  } catch (error) {
+    return { error: error.message, success: false };
+  }
+}
+async function getCommandOutput({ shell_id, filter }) {
+  const shellProcess = shellProcesses.get(shell_id);
+  if (!shellProcess) {
+    return {
+      error: `Shell ID ${shell_id} not found`,
+      output: "",
+      running: false,
+      stderr: "",
+      stdout: "",
+      success: false
+    };
+  }
+  const { lastReadStderr, lastReadStdout, process: childProcess, stderr, stdout } = shellProcess;
+  const newStdout = stdout.slice(lastReadStdout).join("");
+  const newStderr = stderr.slice(lastReadStderr).join("");
+  let output = newStdout + newStderr;
+  if (filter) {
+    try {
+      const regex = new RegExp(filter, "gm");
+      const lines = output.split("\n");
+      output = lines.filter((line) => regex.test(line)).join("\n");
+    } catch {
+    }
+  }
+  shellProcess.lastReadStdout = stdout.length;
+  shellProcess.lastReadStderr = stderr.length;
+  const running = childProcess.exitCode === null;
+  return {
+    output: truncateOutput(output),
+    running,
+    stderr: truncateOutput(newStderr),
+    stdout: truncateOutput(newStdout),
+    success: true
+  };
+}
+async function killCommand({ shell_id }) {
+  const shellProcess = shellProcesses.get(shell_id);
+  if (!shellProcess) {
+    return { error: `Shell ID ${shell_id} not found`, success: false };
+  }
+  try {
+    shellProcess.process.kill();
+    shellProcesses.delete(shell_id);
+    return { success: true };
+  } catch (error) {
+    return { error: error.message, success: false };
+  }
+}
+
+// src/tools/index.ts
+var methodMap = {
+  editLocalFile,
+  getCommandOutput,
+  globLocalFiles,
+  grepContent,
+  killCommand,
+  listLocalFiles,
+  readLocalFile,
+  runCommand,
+  searchLocalFiles,
+  writeLocalFile
+};
+async function executeToolCall(apiName, argsStr) {
+  const handler = methodMap[apiName];
+  if (!handler) {
+    return { content: "", error: `Unknown tool API: ${apiName}`, success: false };
+  }
+  try {
+    const args = JSON.parse(argsStr);
+    const result = await handler(args);
+    const content = typeof result === "string" ? result : JSON.stringify(result);
+    return { content, success: true };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    log.error(`Tool call failed: ${apiName} - ${errorMsg}`);
+    return { content: "", error: errorMsg, success: false };
+  }
+}
+
+// src/commands/connect.ts
+function registerConnectCommand(program2) {
+  program2.command("connect").description("Connect to the device gateway and listen for tool calls").option("--token <jwt>", "JWT access token").option("--service-token <token>", "Service token (requires --user-id)").option("--user-id <id>", "User ID (required with --service-token)").option("--gateway <url>", "Gateway URL", "https://device-gateway.lobehub.com").option("--device-id <id>", "Device ID (auto-generated if not provided)").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+    if (options.verbose) setVerbose(true);
+    const auth = await resolveToken(options);
+    const client = new GatewayClient({
+      deviceId: options.deviceId,
+      gatewayUrl: options.gateway,
+      logger: log,
+      token: auth.token,
+      userId: auth.userId
+    });
+    log.info("\u2500\u2500\u2500 LobeHub CLI \u2500\u2500\u2500");
+    log.info(`  Device ID : ${client.currentDeviceId}`);
+    log.info(`  Hostname  : ${os3.hostname()}`);
+    log.info(`  Platform  : ${process.platform}`);
+    log.info(`  Gateway   : ${options.gateway || "https://device-gateway.lobehub.com"}`);
+    log.info(`  Auth      : ${options.serviceToken ? "service-token" : "jwt"}`);
+    log.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    client.on("system_info_request", (request) => {
+      log.info(`Received system_info_request: requestId=${request.requestId}`);
+      const systemInfo = collectSystemInfo();
+      client.sendSystemInfoResponse({
+        requestId: request.requestId,
+        result: { success: true, systemInfo }
+      });
+    });
+    client.on("tool_call_request", async (request) => {
+      const { requestId, toolCall } = request;
+      log.toolCall(toolCall.apiName, requestId, toolCall.arguments);
+      const result = await executeToolCall(toolCall.apiName, toolCall.arguments);
+      log.toolResult(requestId, result.success, result.content);
+      client.sendToolCallResponse({
+        requestId,
+        result: {
+          content: result.content,
+          error: result.error,
+          success: result.success
+        }
+      });
+    });
+    client.on("auth_failed", (reason) => {
+      log.error(`Authentication failed: ${reason}`);
+      log.error("Run 'lh login' to re-authenticate.");
+      cleanup();
+      process.exit(1);
+    });
+    client.on("auth_expired", async () => {
+      log.warn("Authentication expired. Attempting to refresh...");
+      const refreshed = await resolveToken({});
+      if (refreshed) {
+        log.info("Token refreshed. Please reconnect.");
+      } else {
+        log.error("Could not refresh token. Run 'lh login' to re-authenticate.");
+      }
+      cleanup();
+      process.exit(1);
+    });
+    client.on("error", (error) => {
+      log.error(`Connection error: ${error.message}`);
+    });
+    const cleanup = () => {
+      log.info("Shutting down...");
+      cleanupAllProcesses();
+      client.disconnect();
+    };
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    await client.connect();
+  });
+}
+function collectSystemInfo() {
+  const home = os3.homedir();
+  const platform = process.platform;
+  const videosDir = platform === "linux" ? "Videos" : "Movies";
+  return {
+    arch: os3.arch(),
+    desktopPath: path3.join(home, "Desktop"),
+    documentsPath: path3.join(home, "Documents"),
+    downloadsPath: path3.join(home, "Downloads"),
+    homePath: home,
+    musicPath: path3.join(home, "Music"),
+    picturesPath: path3.join(home, "Pictures"),
+    userDataPath: path3.join(home, ".lobehub"),
+    videosPath: path3.join(home, videosDir),
+    workingDirectory: process.cwd()
+  };
+}
+
+// src/commands/login.ts
+import { execFile } from "child_process";
+var CLIENT_ID2 = "lobehub-cli";
+var SCOPES = "openid profile email offline_access";
+function registerLoginCommand(program2) {
+  program2.command("login").description("Log in to LobeHub via browser (Device Code Flow)").option("--server <url>", "LobeHub server URL", "https://app.lobehub.com").action(async (options) => {
+    const serverUrl = options.server.replace(/\/$/, "");
+    log.info("Starting login...");
+    let deviceAuth;
+    try {
+      const res = await fetch(`${serverUrl}/oidc/device/auth`, {
+        body: new URLSearchParams({
+          client_id: CLIENT_ID2,
+          resource: "urn:lobehub:chat",
+          scope: SCOPES
+        }),
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        method: "POST"
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        log.error(`Failed to start device authorization: ${res.status} ${text}`);
+        process.exit(1);
+      }
+      deviceAuth = await res.json();
+    } catch (error) {
+      log.error(`Failed to reach server: ${error.message}`);
+      log.error(`Make sure ${serverUrl} is reachable.`);
+      process.exit(1);
+    }
+    const verifyUrl = deviceAuth.verification_uri_complete || deviceAuth.verification_uri;
+    log.info("");
+    log.info("  Open this URL in your browser:");
+    log.info(`  ${verifyUrl}`);
+    log.info("");
+    log.info(`  Enter code: ${deviceAuth.user_code}`);
+    log.info("");
+    openBrowser(verifyUrl);
+    log.info("Waiting for authorization...");
+    const interval = (deviceAuth.interval || 5) * 1e3;
+    const expiresAt = Date.now() + deviceAuth.expires_in * 1e3;
+    let pollInterval = interval;
+    while (Date.now() < expiresAt) {
+      await sleep(pollInterval);
+      try {
+        const res = await fetch(`${serverUrl}/oidc/token`, {
+          body: new URLSearchParams({
+            client_id: CLIENT_ID2,
+            device_code: deviceAuth.device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          }),
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          method: "POST"
+        });
+        const body = await res.json();
+        if (body.error) {
+          switch (body.error) {
+            case "authorization_pending": {
+              break;
+            }
+            case "slow_down": {
+              pollInterval += 5e3;
+              break;
+            }
+            case "access_denied": {
+              log.error("Authorization denied by user.");
+              process.exit(1);
+              break;
+            }
+            case "expired_token": {
+              log.error("Device code expired. Please run login again.");
+              process.exit(1);
+              break;
+            }
+            default: {
+              log.error(`Authorization error: ${body.error} - ${body.error_description || ""}`);
+              process.exit(1);
+            }
+          }
+        } else if (body.access_token) {
+          saveCredentials({
+            accessToken: body.access_token,
+            expiresAt: body.expires_in ? Math.floor(Date.now() / 1e3) + body.expires_in : void 0,
+            refreshToken: body.refresh_token,
+            serverUrl
+          });
+          log.info("Login successful! Credentials saved.");
+          return;
+        }
+      } catch {
+      }
+    }
+    log.error("Device code expired. Please run login again.");
+    process.exit(1);
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function openBrowser(url) {
+  if (process.platform === "win32") {
+    execFile("rundll32", ["url.dll,FileProtocolHandler", url], (err) => {
+      if (err) {
+        log.debug(`Could not open browser automatically: ${err.message}`);
+      }
+    });
+  } else {
+    const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+    execFile(cmd, [url], (err) => {
+      if (err) {
+        log.debug(`Could not open browser automatically: ${err.message}`);
+      }
+    });
+  }
+}
+
+// src/commands/logout.ts
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Log out and remove stored credentials").action(() => {
+    const removed = clearCredentials();
+    if (removed) {
+      log.info("Logged out. Credentials removed.");
+    } else {
+      log.info("No credentials found. Already logged out.");
+    }
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program2) {
+  program2.command("status").description("Check if gateway connection can be established").option("--token <jwt>", "JWT access token").option("--service-token <token>", "Service token (requires --user-id)").option("--user-id <id>", "User ID (required with --service-token)").option("--gateway <url>", "Gateway URL", "https://device-gateway.lobehub.com").option("--timeout <ms>", "Connection timeout in ms", "10000").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+    if (options.verbose) setVerbose(true);
+    const auth = await resolveToken(options);
+    const timeout = Number.parseInt(options.timeout || "10000", 10);
+    const client = new GatewayClient({
+      autoReconnect: false,
+      gatewayUrl: options.gateway,
+      logger: log,
+      token: auth.token,
+      userId: auth.userId
+    });
+    const timer = setTimeout(() => {
+      log.error("FAILED - Connection timed out");
+      client.disconnect();
+      process.exit(1);
+    }, timeout);
+    client.on("connected", () => {
+      clearTimeout(timer);
+      log.info("CONNECTED");
+      client.disconnect();
+      process.exit(0);
+    });
+    client.on("disconnected", () => {
+      clearTimeout(timer);
+      log.error("FAILED - Connection closed by server");
+      process.exit(1);
+    });
+    client.on("auth_failed", (reason) => {
+      clearTimeout(timer);
+      log.error(`FAILED - Authentication failed: ${reason}`);
+      process.exit(1);
+    });
+    client.on("auth_expired", () => {
+      clearTimeout(timer);
+      log.error("FAILED - Authentication expired");
+      client.disconnect();
+      process.exit(1);
+    });
+    client.on("error", (error) => {
+      log.error(`Connection error: ${error.message}`);
+    });
+    await client.connect();
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lh").description("LobeHub CLI - manage and connect to LobeHub services").version("0.1.0");
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerConnectCommand(program);
+registerStatusCommand(program);
+program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lobehub/cli",
+  "version": "0.0.1-canary.1",
+  "type": "module",
+  "bin": {
+    "lh": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npx tsup",
+    "dev": "bun src/index.ts",
+    "prepublishOnly": "npm run build",
+    "test": "bunx vitest run --config vitest.config.mts --silent='passed-only'",
+    "test:coverage": "bunx vitest run --config vitest.config.mts --coverage",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "diff": "^7.0.0",
+    "fast-glob": "^3.3.3",
+    "picocolors": "^1.1.1",
+    "ws": "^8.18.1"
+  },
+  "devDependencies": {
+    "@lobechat/device-gateway-client": "workspace:*",
+    "@types/diff": "^6.0.0",
+    "@types/node": "^22.13.5",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}