@lobehub/cli 0.0.1-canary.1 → 0.0.1-canary.3

package/dist/index.js

@@ -4,8 +4,9 @@
 import { Command } from "commander";
 
 // src/commands/connect.ts
-import os3 from "os";
-import path3 from "path";
+import fs3 from "fs";
+import os4 from "os";
+import path4 from "path";
 
 // ../../packages/device-gateway-client/src/client.ts
 import { randomUUID } from "crypto";
@@ -440,9 +441,132 @@ async function resolveToken(options) {
   process.exit(1);
 }
 
+// src/daemon/manager.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import os3 from "os";
+import path2 from "path";
+var MAX_LOG_SIZE = 5 * 1024 * 1024;
+function getLobehubDir() {
+  return path2.join(os3.homedir(), ".lobehub");
+}
+function getPidPath() {
+  return path2.join(getLobehubDir(), "daemon.pid");
+}
+function getStatusPath() {
+  return path2.join(getLobehubDir(), "daemon.status.json");
+}
+function getLogFilePath() {
+  return path2.join(getLobehubDir(), "daemon.log");
+}
+function ensureDir() {
+  fs2.mkdirSync(getLobehubDir(), { mode: 448, recursive: true });
+}
+function readPid() {
+  try {
+    const raw = fs2.readFileSync(getPidPath(), "utf8").trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function writePid(pid) {
+  ensureDir();
+  fs2.writeFileSync(getPidPath(), String(pid), { mode: 384 });
+}
+function removePid() {
+  try {
+    fs2.unlinkSync(getPidPath());
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRunningDaemonPid() {
+  const pid = readPid();
+  if (pid === null) return null;
+  if (isProcessAlive(pid)) return pid;
+  removePid();
+  removeStatus();
+  return null;
+}
+function writeStatus(status) {
+  ensureDir();
+  fs2.writeFileSync(getStatusPath(), JSON.stringify(status, null, 2), { mode: 384 });
+}
+function readStatus() {
+  try {
+    return JSON.parse(fs2.readFileSync(getStatusPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function removeStatus() {
+  try {
+    fs2.unlinkSync(getStatusPath());
+  } catch {
+  }
+}
+function getLogPath() {
+  return getLogFilePath();
+}
+function rotateLogIfNeeded() {
+  try {
+    const stat2 = fs2.statSync(getLogFilePath());
+    if (stat2.size > MAX_LOG_SIZE) {
+      const rotated = getLogFilePath() + ".1";
+      try {
+        fs2.unlinkSync(rotated);
+      } catch {
+      }
+      fs2.renameSync(getLogFilePath(), rotated);
+    }
+  } catch {
+  }
+}
+function appendLog(line) {
+  ensureDir();
+  rotateLogIfNeeded();
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  fs2.appendFileSync(getLogFilePath(), `[${ts}] ${line}
+`);
+}
+function spawnDaemon(args) {
+  ensureDir();
+  const logFd = fs2.openSync(getLogFilePath(), "a");
+  const child = spawn(process.execPath, [...process.execArgv, ...args, "--daemon-child"], {
+    detached: true,
+    env: { ...process.env, LOBEHUB_DAEMON: "1" },
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  const pid = child.pid;
+  writePid(pid);
+  fs2.closeSync(logFd);
+  return pid;
+}
+function stopDaemon() {
+  const pid = getRunningDaemonPid();
+  if (pid === null) return false;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  removePid();
+  removeStatus();
+  return true;
+}
+
 // src/tools/file.ts
 import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 import { createPatch } from "diff";
 import fg from "fast-glob";
 async function readLocalFile({ path: filePath, loc, fullContent }) {
@@ -472,8 +596,8 @@ async function readLocalFile({ path: filePath, loc, fullContent }) {
       charCount: selectedContent.length,
       content: selectedContent,
       createdTime: fileStat.birthtime,
-      fileType: path2.extname(filePath).toLowerCase().replace(".", "") || "unknown",
-      filename: path2.basename(filePath),
+      fileType: path3.extname(filePath).toLowerCase().replace(".", "") || "unknown",
+      filename: path3.basename(filePath),
       lineCount,
       loc: actualLoc,
       modifiedTime: fileStat.mtime,
@@ -486,8 +610,8 @@ async function readLocalFile({ path: filePath, loc, fullContent }) {
       charCount: 0,
       content: `Error accessing or processing file: ${errorMessage}`,
       createdTime: /* @__PURE__ */ new Date(),
-      fileType: path2.extname(filePath).toLowerCase().replace(".", "") || "unknown",
-      filename: path2.basename(filePath),
+      fileType: path3.extname(filePath).toLowerCase().replace(".", "") || "unknown",
+      filename: path3.basename(filePath),
       lineCount: 0,
       loc: [0, 0],
       modifiedTime: /* @__PURE__ */ new Date(),
@@ -500,7 +624,7 @@ 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);
+    const dirname = path3.dirname(filePath);
     await mkdir(dirname, { recursive: true });
     await writeFile(filePath, content, "utf8");
     log.debug(`File written: ${filePath} (${content.length} chars)`);
@@ -565,7 +689,7 @@ async function listLocalFiles({
     const entries = await readdir(dirPath);
     const results = [];
     for (const entry of entries) {
-      const fullPath = path2.join(dirPath, entry);
+      const fullPath = path3.join(dirPath, entry);
       try {
         const stats = await stat(fullPath);
         const isDirectory = stats.isDirectory();
@@ -577,7 +701,7 @@ async function listLocalFiles({
           name: entry,
           path: fullPath,
           size: stats.size,
-          type: isDirectory ? "directory" : path2.extname(entry).toLowerCase().replace(".", "")
+          type: isDirectory ? "directory" : path3.extname(entry).toLowerCase().replace(".", "")
         });
       } catch {
       }
@@ -627,12 +751,12 @@ async function globLocalFiles({ pattern, cwd }) {
   }
 }
 async function grepContent({ pattern, cwd, filePattern }) {
-  const { spawn: spawn2 } = await import("child_process");
+  const { spawn: spawn3 } = 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() });
+    const child = spawn3("rg", args, { cwd: cwd || process.cwd() });
     let stdout = "";
     child.stdout?.on("data", (data) => {
       stdout += data.toString();
@@ -677,7 +801,7 @@ async function searchLocalFiles({
       dot: false,
       ignore: ["**/node_modules/**", "**/.git/**"]
     });
-    let results = files.map((f) => ({ name: path2.basename(f), path: path2.join(cwd, f) }));
+    let results = files.map((f) => ({ name: path3.basename(f), path: path3.join(cwd, f) }));
     if (contentContains) {
       const filtered = [];
       for (const file of results) {
@@ -699,7 +823,7 @@ async function searchLocalFiles({
 }
 
 // src/tools/shell.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 var MAX_OUTPUT_LENGTH = 8e4;
 var ANSI_REGEX = (
@@ -735,7 +859,7 @@ async function runCommand({
   try {
     if (run_in_background) {
       const shellId = randomUUID2();
-      const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+      const childProcess = spawn2(shellConfig.cmd, shellConfig.args, {
         env: process.env,
         shell: false
       });
@@ -760,7 +884,7 @@ async function runCommand({
       return { shell_id: shellId, success: true };
     } else {
       return new Promise((resolve) => {
-        const childProcess = spawn(shellConfig.cmd, shellConfig.args, {
+        const childProcess = spawn2(shellConfig.cmd, shellConfig.args, {
           env: process.env,
           shell: false
         });
@@ -892,95 +1016,235 @@ async function executeToolCall(apiName, argsStr) {
 
 // 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) => {
+  const connectCmd = program2.command("connect").description("Connect to the device gateway and listen for tool calls").option("--token <jwt>", "JWT access 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").option("-d, --daemon", "Run as a background daemon process").option("--daemon-child", "Internal: runs as the daemon child process").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 }
+    if (options.daemon) {
+      return handleDaemonStart(options);
+    }
+    const isDaemonChild = options.daemonChild || process.env.LOBEHUB_DAEMON === "1";
+    await runConnect(options, isDaemonChild);
+  });
+  connectCmd.command("stop").description("Stop the background daemon process").action(() => {
+    const stopped = stopDaemon();
+    if (stopped) {
+      log.info("Daemon stopped.");
+    } else {
+      log.warn("No daemon is running.");
+    }
+  });
+  connectCmd.command("status").description("Show background daemon status").action(() => {
+    const pid = getRunningDaemonPid();
+    if (pid === null) {
+      log.info("No daemon is running.");
+      return;
+    }
+    const status = readStatus();
+    log.info("\u2500\u2500\u2500 Daemon Status \u2500\u2500\u2500");
+    log.info(`  PID              : ${pid}`);
+    if (status) {
+      log.info(`  Started at       : ${status.startedAt}`);
+      log.info(`  Connection       : ${status.connectionStatus}`);
+      log.info(`  Gateway          : ${status.gatewayUrl}`);
+      const uptime = formatUptime(new Date(status.startedAt));
+      log.info(`  Uptime           : ${uptime}`);
+    }
+    log.info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  });
+  connectCmd.command("logs").description("Tail the daemon log file").option("-n, --lines <count>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action(async (opts) => {
+    const logPath = getLogPath();
+    if (!fs3.existsSync(logPath)) {
+      log.warn("No log file found. Start the daemon first.");
+      return;
+    }
+    const lines = opts.lines || "50";
+    const args = [`-n`, lines];
+    if (opts.follow) args.push("-f");
+    try {
+      const { execFileSync } = await import("child_process");
+      execFileSync("tail", [...args, logPath], { stdio: "inherit" });
+    } catch {
+    }
+  });
+  connectCmd.command("restart").description("Restart the background daemon process").option("--token <jwt>", "JWT access token").option("--gateway <url>", "Gateway URL", "https://device-gateway.lobehub.com").option("--device-id <id>", "Device ID").option("-v, --verbose", "Enable verbose logging").action((options) => {
+    const wasStopped = stopDaemon();
+    if (wasStopped) {
+      log.info("Stopped existing daemon.");
+    }
+    handleDaemonStart({ ...options, daemon: true });
+  });
+}
+function handleDaemonStart(options) {
+  const existingPid = getRunningDaemonPid();
+  if (existingPid !== null) {
+    log.error(`Daemon is already running (PID ${existingPid}).`);
+    log.error("Use 'lh connect stop' to stop it, or 'lh connect restart' to restart.");
+    process.exit(1);
+  }
+  const args = buildDaemonArgs(options);
+  const pid = spawnDaemon(args);
+  log.info(`Daemon started (PID ${pid}).`);
+  log.info(`  Logs: ${getLogPath()}`);
+  log.info("  Run 'lh connect status' to check connection.");
+  log.info("  Run 'lh connect stop' to stop.");
+}
+function buildDaemonArgs(options) {
+  const script = process.argv[1];
+  const args = [script, "connect"];
+  if (options.token) args.push("--token", options.token);
+  if (options.gateway) args.push("--gateway", options.gateway);
+  if (options.deviceId) args.push("--device-id", options.deviceId);
+  if (options.verbose) args.push("--verbose");
+  return args;
+}
+async function runConnect(options, isDaemonChild) {
+  const auth = await resolveToken(options);
+  const gatewayUrl = options.gateway || "https://device-gateway.lobehub.com";
+  const client = new GatewayClient({
+    deviceId: options.deviceId,
+    gatewayUrl,
+    logger: isDaemonChild ? createDaemonLogger() : log,
+    token: auth.token,
+    userId: auth.userId
+  });
+  const info = (msg) => {
+    if (isDaemonChild) appendLog(msg);
+    else log.info(msg);
+  };
+  const error = (msg) => {
+    if (isDaemonChild) appendLog(`[ERROR] ${msg}`);
+    else log.error(msg);
+  };
+  info("\u2500\u2500\u2500 LobeHub CLI \u2500\u2500\u2500");
+  info(`  Device ID : ${client.currentDeviceId}`);
+  info(`  Hostname  : ${os4.hostname()}`);
+  info(`  Platform  : ${process.platform}`);
+  info(`  Gateway   : ${gatewayUrl}`);
+  info(`  Auth      : jwt`);
+  info(`  Mode      : ${isDaemonChild ? "daemon" : "foreground"}`);
+  info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  const updateStatus = (connectionStatus) => {
+    if (isDaemonChild) {
+      writeStatus({
+        connectionStatus,
+        gatewayUrl,
+        pid: process.pid,
+        startedAt: startedAt.toISOString()
       });
+    }
+  };
+  const startedAt = /* @__PURE__ */ new Date();
+  updateStatus("connecting");
+  client.on("system_info_request", (request) => {
+    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;
+  });
+  client.on("tool_call_request", async (request) => {
+    const { requestId, toolCall } = request;
+    if (isDaemonChild) {
+      appendLog(`[TOOL] ${toolCall.apiName} (${requestId})`);
+    } else {
       log.toolCall(toolCall.apiName, requestId, toolCall.arguments);
-      const result = await executeToolCall(toolCall.apiName, toolCall.arguments);
+    }
+    const result = await executeToolCall(toolCall.apiName, toolCall.arguments);
+    if (isDaemonChild) {
+      appendLog(`[RESULT] ${result.success ? "OK" : "FAIL"} (${requestId})`);
+    } else {
       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.");
+    }
+    client.sendToolCallResponse({
+      requestId,
+      result: {
+        content: result.content,
+        error: result.error,
+        success: result.success
       }
-      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();
   });
+  client.on("connected", () => {
+    updateStatus("connected");
+  });
+  client.on("disconnected", () => {
+    updateStatus("disconnected");
+  });
+  client.on("reconnecting", () => {
+    updateStatus("reconnecting");
+  });
+  client.on("auth_failed", (reason) => {
+    error(`Authentication failed: ${reason}`);
+    error("Run 'lh login' to re-authenticate.");
+    cleanup();
+    process.exit(1);
+  });
+  client.on("auth_expired", async () => {
+    error("Authentication expired. Attempting to refresh...");
+    const refreshed = await resolveToken({});
+    if (refreshed) {
+      info("Token refreshed. Please reconnect.");
+    } else {
+      error("Could not refresh token. Run 'lh login' to re-authenticate.");
+    }
+    cleanup();
+    process.exit(1);
+  });
+  client.on("error", (err) => {
+    error(`Connection error: ${err.message}`);
+  });
+  const cleanup = () => {
+    info("Shutting down...");
+    cleanupAllProcesses();
+    client.disconnect();
+    if (isDaemonChild) {
+      removeStatus();
+      removePid();
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  await client.connect();
+}
+function createDaemonLogger() {
+  return {
+    debug: (msg) => appendLog(`[DEBUG] ${msg}`),
+    error: (msg) => appendLog(`[ERROR] ${msg}`),
+    info: (msg) => appendLog(`[INFO] ${msg}`),
+    warn: (msg) => appendLog(`[WARN] ${msg}`)
+  };
+}
+function formatUptime(startedAt) {
+  const diff = Date.now() - startedAt.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h ${minutes % 60}m`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
 }
 function collectSystemInfo() {
-  const home = os3.homedir();
+  const home = os4.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"),
+    arch: os4.arch(),
+    desktopPath: path4.join(home, "Desktop"),
+    documentsPath: path4.join(home, "Documents"),
+    downloadsPath: path4.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),
+    musicPath: path4.join(home, "Music"),
+    picturesPath: path4.join(home, "Pictures"),
+    userDataPath: path4.join(home, ".lobehub"),
+    videosPath: path4.join(home, videosDir),
     workingDirectory: process.cwd()
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/cli",
-  "version": "0.0.1-canary.1",
+  "version": "0.0.1-canary.3",
   "type": "module",
   "bin": {
     "lh": "./dist/index.js"