skillo 0.2.5 → 0.2.8

package/dist/chunk-XLJGCOVT.js

@@ -0,0 +1,975 @@
+#!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-VAQ73XPE.js";
+import {
+  StatusWriter
+} from "./chunk-6UGTWBUW.js";
+import {
+  loadConfig
+} from "./chunk-QUXHHRRK.js";
+import {
+  ensureDirectory,
+  getActiveSessionsDir,
+  getConfigFile,
+  getDataDir,
+  getLogFile,
+  getPidFile,
+  getTrackedProjectsCacheFile
+} from "./chunk-63FVALWX.js";
+
+// src/commands/daemon.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3 } from "fs";
+import { fork, spawn } from "child_process";
+import { join as join2 } from "path";
+import { Command } from "commander";
+
+// src/utils/os-service.ts
+import { existsSync, writeFileSync, unlinkSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { execSync } from "child_process";
+var DAEMON_LABEL = "one.skillo.daemon";
+var TRAY_LABEL = "one.skillo.tray";
+var WIN_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+var WIN_DAEMON_VALUE = "SkilloDaemon";
+var WIN_TRAY_VALUE = "SkilloTray";
+var isWin = platform() === "win32";
+var pathSep = isWin ? ";" : ":";
+function getLaunchAgentsDir() {
+  return join(homedir(), "Library", "LaunchAgents");
+}
+function getSystemdUserDir() {
+  return join(homedir(), ".config", "systemd", "user");
+}
+function getDaemonPlistPath() {
+  return join(getLaunchAgentsDir(), `${DAEMON_LABEL}.plist`);
+}
+function getTrayPlistPath() {
+  return join(getLaunchAgentsDir(), `${TRAY_LABEL}.plist`);
+}
+function getDaemonServicePath() {
+  return join(getSystemdUserDir(), "skillo-daemon.service");
+}
+function getTrayServicePath() {
+  return join(getSystemdUserDir(), "skillo-tray.service");
+}
+function getSkilloDataDir() {
+  return join(homedir(), ".skillo");
+}
+function getWinDaemonVbsPath() {
+  return join(getSkilloDataDir(), "skillo-daemon.vbs");
+}
+function findSkilloBin() {
+  try {
+    const whichCmd = isWin ? "where skillo" : "which skillo";
+    const result = execSync(whichCmd, { encoding: "utf-8" }).trim();
+    const firstLine = result.split(/\r?\n/)[0].trim();
+    if (firstLine) return firstLine;
+  } catch {
+  }
+  if (isWin) {
+    const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+    const candidates = [
+      join(appData, "npm", "skillo.cmd"),
+      join(homedir(), "AppData", "Local", "fnm_multishells")
+    ];
+    for (const c of candidates) {
+      if (existsSync(c)) return c;
+    }
+  } else {
+    const candidates = [
+      "/usr/local/bin/skillo",
+      "/usr/bin/skillo"
+    ];
+    for (const c of candidates) {
+      if (existsSync(c)) return c;
+    }
+  }
+  return "skillo";
+}
+function buildPath() {
+  const paths = /* @__PURE__ */ new Set();
+  const home = homedir();
+  (process.env.PATH || "").split(pathSep).forEach((p) => paths.add(p));
+  if (isWin) {
+    const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+    paths.add(join(appData, "npm"));
+    paths.add(join(home, "AppData", "Local", "Programs", "nodejs"));
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) paths.add(nvmHome);
+    const nvmSymlink = process.env.NVM_SYMLINK;
+    if (nvmSymlink) paths.add(nvmSymlink);
+    const fnmDir = join(home, ".fnm");
+    if (existsSync(fnmDir)) paths.add(fnmDir);
+  } else {
+    const nvmDir = process.env.NVM_DIR || join(home, ".nvm");
+    if (existsSync(nvmDir)) {
+      try {
+        const defaultAlias = join(nvmDir, "alias", "default");
+        if (existsSync(defaultAlias)) {
+          const versionsDir = join(nvmDir, "versions", "node");
+          if (existsSync(versionsDir)) {
+            const versions = readdirSync(versionsDir);
+            for (const v of versions) {
+              paths.add(join(versionsDir, v, "bin"));
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    paths.add(join(home, ".fnm", "current", "bin"));
+    paths.add("/opt/homebrew/bin");
+    paths.add("/usr/local/bin");
+    paths.add("/usr/bin");
+    paths.add("/bin");
+    paths.add(join(home, ".npm-global", "bin"));
+    paths.add(join(home, ".local", "bin"));
+  }
+  return [...paths].filter(Boolean).join(pathSep);
+}
+function generateDaemonPlist(skilloBin, envPath) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${DAEMON_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${skilloBin}</string>
+        <string>start</string>
+        <string>--foreground</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${envPath}</string>
+        <key>HOME</key>
+        <string>${homedir()}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${join(homedir(), ".skillo", "launchd-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join(homedir(), ".skillo", "launchd-stderr.log")}</string>
+</dict>
+</plist>`;
+}
+function generateTrayPlist(skilloBin, envPath) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${TRAY_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${skilloBin}</string>
+        <string>tray</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>LimitLoadToSessionType</key>
+    <string>Aqua</string>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${envPath}</string>
+        <key>HOME</key>
+        <string>${homedir()}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${join(homedir(), ".skillo", "launchd-tray-stdout.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${join(homedir(), ".skillo", "launchd-tray-stderr.log")}</string>
+</dict>
+</plist>`;
+}
+function generateDaemonUnit(skilloBin, envPath) {
+  return `[Unit]
+Description=Skillo Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${skilloBin} start --foreground
+Restart=on-failure
+RestartSec=10
+Environment=PATH=${envPath}
+Environment=HOME=${homedir()}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function generateTrayUnit(skilloBin, envPath) {
+  return `[Unit]
+Description=Skillo Tray Icon
+After=graphical-session.target
+PartOf=graphical-session.target
+
+[Service]
+Type=simple
+ExecStart=${skilloBin} tray
+Restart=on-failure
+RestartSec=10
+Environment=PATH=${envPath}
+Environment=HOME=${homedir()}
+Environment=DISPLAY=:0
+
+[Install]
+WantedBy=graphical-session.target
+`;
+}
+function generateDaemonVbs(skilloBin) {
+  const escaped = skilloBin.replace(/\\/g, "\\\\");
+  return `' Skillo Daemon \u2014 hidden launcher\r
+Set WshShell = CreateObject("WScript.Shell")\r
+WshShell.Run """${escaped}"" start --foreground", 0, False\r
+`;
+}
+function winRegAdd(valueName, data) {
+  execSync(
+    `reg add "${WIN_REG_KEY}" /v "${valueName}" /t REG_SZ /d "${data}" /f`,
+    { stdio: "ignore" }
+  );
+}
+function winRegDelete(valueName) {
+  try {
+    execSync(
+      `reg delete "${WIN_REG_KEY}" /v "${valueName}" /f`,
+      { stdio: "ignore" }
+    );
+  } catch {
+  }
+}
+function winRegExists(valueName) {
+  try {
+    execSync(`reg query "${WIN_REG_KEY}" /v "${valueName}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installService(options) {
+  const os = platform();
+  const skilloBin = findSkilloBin();
+  const envPath = buildPath();
+  const includeTray = options?.includeTray ?? true;
+  try {
+    if (os === "darwin") {
+      const agentsDir = getLaunchAgentsDir();
+      if (!existsSync(agentsDir)) mkdirSync(agentsDir, { recursive: true });
+      const daemonPlist = getDaemonPlistPath();
+      writeFileSync(daemonPlist, generateDaemonPlist(skilloBin, envPath), "utf-8");
+      try {
+        execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
+      } catch {
+      }
+      execSync(`launchctl load "${daemonPlist}"`);
+      if (includeTray) {
+        const trayPlist = getTrayPlistPath();
+        writeFileSync(trayPlist, generateTrayPlist(skilloBin, envPath), "utf-8");
+        try {
+          execSync(`launchctl unload "${trayPlist}" 2>/dev/null`);
+        } catch {
+        }
+        execSync(`launchctl load "${trayPlist}"`);
+      }
+      return { success: true };
+    } else if (os === "linux") {
+      const systemdDir = getSystemdUserDir();
+      if (!existsSync(systemdDir)) mkdirSync(systemdDir, { recursive: true });
+      writeFileSync(getDaemonServicePath(), generateDaemonUnit(skilloBin, envPath), "utf-8");
+      execSync("systemctl --user daemon-reload");
+      execSync("systemctl --user enable skillo-daemon.service");
+      execSync("systemctl --user start skillo-daemon.service");
+      if (includeTray) {
+        writeFileSync(getTrayServicePath(), generateTrayUnit(skilloBin, envPath), "utf-8");
+        execSync("systemctl --user daemon-reload");
+        execSync("systemctl --user enable skillo-tray.service");
+        try {
+          execSync("systemctl --user start skillo-tray.service");
+        } catch {
+        }
+      }
+      return { success: true };
+    } else if (os === "win32") {
+      const dataDir = getSkilloDataDir();
+      if (!existsSync(dataDir)) mkdirSync(dataDir, { recursive: true });
+      const vbsPath = getWinDaemonVbsPath();
+      writeFileSync(vbsPath, generateDaemonVbs(skilloBin), "utf-8");
+      winRegAdd(WIN_DAEMON_VALUE, `wscript.exe "${vbsPath}"`);
+      if (includeTray) {
+        winRegAdd(WIN_TRAY_VALUE, `"${skilloBin}" tray`);
+      }
+      return { success: true };
+    } else {
+      return { success: false, error: `Unsupported platform: ${os}. Auto-start is available on macOS, Linux, and Windows.` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function uninstallService() {
+  const os = platform();
+  try {
+    if (os === "darwin") {
+      const daemonPlist = getDaemonPlistPath();
+      if (existsSync(daemonPlist)) {
+        try {
+          execSync(`launchctl unload "${daemonPlist}" 2>/dev/null`);
+        } catch {
+        }
+        unlinkSync(daemonPlist);
+      }
+      const trayPlist = getTrayPlistPath();
+      if (existsSync(trayPlist)) {
+        try {
+          execSync(`launchctl unload "${trayPlist}" 2>/dev/null`);
+        } catch {
+        }
+        unlinkSync(trayPlist);
+      }
+      return { success: true };
+    } else if (os === "linux") {
+      const daemonService = getDaemonServicePath();
+      if (existsSync(daemonService)) {
+        try {
+          execSync("systemctl --user stop skillo-daemon.service 2>/dev/null");
+        } catch {
+        }
+        try {
+          execSync("systemctl --user disable skillo-daemon.service 2>/dev/null");
+        } catch {
+        }
+        unlinkSync(daemonService);
+      }
+      const trayService = getTrayServicePath();
+      if (existsSync(trayService)) {
+        try {
+          execSync("systemctl --user stop skillo-tray.service 2>/dev/null");
+        } catch {
+        }
+        try {
+          execSync("systemctl --user disable skillo-tray.service 2>/dev/null");
+        } catch {
+        }
+        unlinkSync(trayService);
+      }
+      try {
+        execSync("systemctl --user daemon-reload");
+      } catch {
+      }
+      return { success: true };
+    } else if (os === "win32") {
+      winRegDelete(WIN_DAEMON_VALUE);
+      winRegDelete(WIN_TRAY_VALUE);
+      const vbsPath = getWinDaemonVbsPath();
+      if (existsSync(vbsPath)) {
+        try {
+          unlinkSync(vbsPath);
+        } catch {
+        }
+      }
+      return { success: true };
+    } else {
+      return { success: false, error: `Unsupported platform: ${os}` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function getServiceStatus() {
+  const os = platform();
+  if (os === "darwin") {
+    const daemonInstalled = existsSync(getDaemonPlistPath());
+    const trayInstalled = existsSync(getTrayPlistPath());
+    let daemonLoaded = false;
+    let trayLoaded = false;
+    try {
+      const output = execSync("launchctl list", { encoding: "utf-8" });
+      daemonLoaded = output.includes(DAEMON_LABEL);
+      trayLoaded = output.includes(TRAY_LABEL);
+    } catch {
+    }
+    return {
+      platform: "macos",
+      daemon: { installed: daemonInstalled, loaded: daemonLoaded },
+      tray: { installed: trayInstalled, loaded: trayLoaded }
+    };
+  } else if (os === "linux") {
+    const daemonInstalled = existsSync(getDaemonServicePath());
+    const trayInstalled = existsSync(getTrayServicePath());
+    let daemonLoaded = false;
+    let trayLoaded = false;
+    try {
+      execSync("systemctl --user is-active skillo-daemon.service", { encoding: "utf-8" });
+      daemonLoaded = true;
+    } catch {
+    }
+    try {
+      execSync("systemctl --user is-active skillo-tray.service", { encoding: "utf-8" });
+      trayLoaded = true;
+    } catch {
+    }
+    return {
+      platform: "linux",
+      daemon: { installed: daemonInstalled, loaded: daemonLoaded },
+      tray: { installed: trayInstalled, loaded: trayLoaded }
+    };
+  } else if (os === "win32") {
+    const daemonInstalled = winRegExists(WIN_DAEMON_VALUE);
+    const trayInstalled = winRegExists(WIN_TRAY_VALUE);
+    return {
+      platform: "windows",
+      daemon: { installed: daemonInstalled, loaded: daemonInstalled },
+      tray: { installed: trayInstalled, loaded: trayInstalled }
+    };
+  }
+  return {
+    platform: "unsupported",
+    daemon: { installed: false, loaded: false },
+    tray: { installed: false, loaded: false }
+  };
+}
+
+// src/utils/daemon-tasks.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, readdirSync as readdirSync2 } from "fs";
+async function updateTrackedProjectsCache(client, log) {
+  try {
+    const result = await client.listProjects(true);
+    if (result.success && result.data?.projects) {
+      const projects = result.data.projects.filter((p) => p.trackingEnabled).map((p) => ({ path: p.path, name: p.name, gitRemoteNormalized: p.gitRemoteNormalized }));
+      const cacheData = { updatedAt: Date.now(), projects };
+      writeFileSync2(getTrackedProjectsCacheFile(), JSON.stringify(cacheData, null, 2));
+      log("DEBUG", `Updated tracked projects cache: ${projects.length} project(s)`);
+      return projects;
+    }
+  } catch (error) {
+    log("ERROR", `Failed to update tracked projects cache: ${error}`);
+  }
+  return null;
+}
+async function cleanupStaleSessions(client, log) {
+  const sessionsDir = getActiveSessionsDir();
+  if (!existsSync2(sessionsDir)) return;
+  try {
+    const files = readdirSync2(sessionsDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const pid = parseInt(file.replace(".json", ""), 10);
+      if (isNaN(pid)) continue;
+      let isRunning = false;
+      try {
+        process.kill(pid, 0);
+        isRunning = true;
+      } catch {
+      }
+      if (!isRunning) {
+        try {
+          const sessionData = JSON.parse(readFileSync2(`${sessionsDir}/${file}`, "utf-8"));
+          if (sessionData.sessionId) {
+            await client.endSession(sessionData.sessionId);
+            log("INFO", `Ended stale session ${sessionData.sessionId.slice(0, 8)} (PID ${pid} dead)`);
+          }
+          unlinkSync2(`${sessionsDir}/${file}`);
+        } catch {
+          try {
+            unlinkSync2(`${sessionsDir}/${file}`);
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (error) {
+    log("ERROR", `Stale session cleanup error: ${error}`);
+  }
+}
+
+// src/commands/daemon.ts
+function isDaemonRunning() {
+  const pidFile = getPidFile();
+  if (!existsSync3(pidFile)) {
+    return { running: false, pid: null };
+  }
+  try {
+    const pidStr = readFileSync3(pidFile, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      return { running: false, pid: null };
+    }
+    try {
+      process.kill(pid, 0);
+      return { running: true, pid };
+    } catch {
+      try {
+        unlinkSync3(pidFile);
+      } catch {
+      }
+      return { running: false, pid: null };
+    }
+  } catch {
+    return { running: false, pid: null };
+  }
+}
+function startDaemonProcess() {
+  const daemonScript = new URL("./daemon-runner.js", import.meta.url).pathname;
+  if (process.platform === "win32") {
+    const scriptPath = daemonScript.replace(/^\/([A-Za-z]:)/, "$1");
+    const child2 = spawn(process.execPath, [scriptPath], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, SKILLO_DAEMON: "1" }
+    });
+    child2.unref();
+    if (child2.pid) {
+      writeFileSync3(getPidFile(), String(child2.pid));
+      return child2.pid;
+    }
+    return null;
+  }
+  const child = fork(daemonScript, [], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      SKILLO_DAEMON: "1"
+    }
+  });
+  child.unref();
+  if (child.pid) {
+    writeFileSync3(getPidFile(), String(child.pid));
+    return child.pid;
+  }
+  return null;
+}
+function isTrayRunning() {
+  const trayPidFile = join2(getDataDir(), "tray.pid");
+  if (!existsSync3(trayPidFile)) return false;
+  try {
+    const pid = parseInt(readFileSync3(trayPidFile, "utf-8").trim(), 10);
+    if (isNaN(pid)) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    try {
+      unlinkSync3(trayPidFile);
+    } catch {
+    }
+    return false;
+  }
+}
+function startTrayProcess() {
+  if (isTrayRunning()) return;
+  const cliEntry = process.argv[1];
+  const child = spawn(process.execPath, [cliEntry, "tray"], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env }
+  });
+  child.unref();
+}
+async function ensureInitialized() {
+  if (existsSync3(getConfigFile())) return;
+  const { getDefaultConfig, saveConfig } = await import("./config-ZOKAP2LJ.js");
+  const { SkilloDatabase } = await import("./database-KQY5OSCS.js");
+  const { getConfigDir, getSkillsDir } = await import("./paths-MPOZBOKE.js");
+  ensureDirectory(getDataDir());
+  ensureDirectory(getConfigDir());
+  ensureDirectory(getSkillsDir());
+  saveConfig(getDefaultConfig());
+  const db = new SkilloDatabase();
+  await db.initialize();
+  db.close();
+  logger_default.dim("Skillo initialized.");
+}
+async function ensureLoggedIn() {
+  const { getApiClient } = await import("./api-client-BF6GDR7Q.js");
+  const client = getApiClient();
+  if (client.hasApiKey()) {
+    const result = await client.authenticate();
+    if (result.success) return true;
+    const err = (result.error || "").toLowerCase();
+    const isAuthFailure = err.includes("unauthorized") || err.includes("invalid") || err.includes("expired") || err.includes("revoked");
+    if (isAuthFailure) {
+      client.clearApiKey();
+      logger_default.warn("Session expired. Logging in again...");
+    } else {
+      logger_default.warn("Could not verify login (server unreachable). Continuing...");
+      return true;
+    }
+  }
+  logger_default.blank();
+  logger_default.info("Login required. Opening browser...");
+  logger_default.blank();
+  const { hostname } = await import("os");
+  const deviceName = `CLI on ${hostname()}`;
+  const deviceAuthResult = await client.startDeviceAuth(deviceName);
+  if (!deviceAuthResult.success || !deviceAuthResult.data) {
+    logger_default.error("Failed to start authentication: " + (deviceAuthResult.error || "Unknown error"));
+    logger_default.dim("You can also login manually: skillo login <api-key>");
+    return false;
+  }
+  const { code, verification_url, interval } = deviceAuthResult.data;
+  logger_default.highlight(`  ${verification_url}`);
+  logger_default.blank();
+  try {
+    const { exec: execCb } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(execCb);
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
+    await execAsync(`${openCmd} "${verification_url}"`);
+    logger_default.dim("Browser opened. Waiting for authorization...");
+  } catch {
+    logger_default.dim("Open the URL above in your browser to authorize.");
+  }
+  logger_default.dim("(Press Ctrl+C to cancel)");
+  const maxAttempts = 120;
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((r) => setTimeout(r, interval * 1e3));
+    const statusResult = await client.checkTokenStatus(code);
+    if (!statusResult.success) continue;
+    const status = statusResult.data?.status;
+    if (status === "ready") {
+      const tokenResult = await client.exchangeToken(code, deviceName);
+      if (tokenResult.success && tokenResult.data) {
+        client.saveApiKey(tokenResult.data.api_key);
+        const authResult = await client.authenticate();
+        logger_default.blank();
+        logger_default.success("Login successful!");
+        if (authResult.success && authResult.data) {
+          logger_default.info(`Welcome, ${authResult.data.user.name}!`);
+        }
+        logger_default.blank();
+        return true;
+      }
+      logger_default.error("Failed to complete login: " + (tokenResult.error || "Unknown error"));
+      return false;
+    }
+    if (status === "expired" || status === "used" || status === "not_found") {
+      logger_default.error(`Authorization ${status}. Please try again.`);
+      return false;
+    }
+  }
+  logger_default.error("Authorization timed out.");
+  return false;
+}
+var startCommand = new Command("start").description("Start the Skillo daemon").option("-f, --foreground", "Run in foreground (don't daemonize)").action(async (options) => {
+  await ensureInitialized();
+  if (!options.foreground) {
+    const loggedIn = await ensureLoggedIn();
+    if (!loggedIn) {
+      process.exit(1);
+    }
+  }
+  const { running, pid } = isDaemonRunning();
+  if (running) {
+    logger_default.success(`Daemon is already running (PID: ${pid})`);
+    const serviceStatus = getServiceStatus();
+    if (!serviceStatus.daemon.installed) {
+      const serviceResult = await installService({ includeTray: true });
+      if (serviceResult.success) {
+        logger_default.dim("Auto-start service installed.");
+      }
+    }
+    if (!isTrayRunning()) {
+      startTrayProcess();
+    }
+    process.exit(0);
+  }
+  if (options.foreground) {
+    logger_default.info("Starting Skillo daemon in foreground...");
+    logger_default.dim("Press Ctrl+C to stop");
+    logger_default.blank();
+    await runDaemonForeground();
+  } else {
+    logger_default.info("Starting Skillo daemon...");
+    const daemonPid = startDaemonProcess();
+    if (daemonPid) {
+      logger_default.success(`Daemon started (PID: ${daemonPid})`);
+      const serviceResult = await installService({ includeTray: true });
+      if (serviceResult.success) {
+        logger_default.dim("Auto-start & tray service installed. Daemon will survive reboots.");
+      }
+      startTrayProcess();
+      logger_default.blank();
+      logger_default.dim("Use 'skillo status' to check daemon status");
+      logger_default.dim("Use 'skillo stop' to stop the daemon");
+    } else {
+      logger_default.error("Failed to start daemon");
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+});
+var stopCommand = new Command("stop").description("Stop the Skillo daemon").action(async () => {
+  const { running, pid } = isDaemonRunning();
+  if (!running) {
+    logger_default.dim("Daemon is not running.");
+    return;
+  }
+  logger_default.info(`Stopping daemon (PID: ${pid})...`);
+  const trayPidFile = join2(getDataDir(), "tray.pid");
+  if (existsSync3(trayPidFile)) {
+    try {
+      const trayPid = parseInt(readFileSync3(trayPidFile, "utf-8").trim(), 10);
+      process.kill(trayPid, "SIGTERM");
+      logger_default.dim("Tray icon stopped.");
+    } catch {
+    }
+    try {
+      unlinkSync3(trayPidFile);
+    } catch {
+    }
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    logger_default.success("Daemon stopped.");
+    logger_default.dim("Auto-start services are still installed. Daemon will restart on login.");
+    logger_default.dim("To remove auto-start: skillo service uninstall");
+  } catch (error) {
+    if (error.code === "ESRCH") {
+      logger_default.dim("Daemon already stopped");
+    } else if (error.code === "EPERM") {
+      logger_default.error("Permission denied. Try with sudo.");
+      process.exit(1);
+    } else {
+      throw error;
+    }
+  }
+  const pidFile = getPidFile();
+  if (existsSync3(pidFile)) {
+    try {
+      unlinkSync3(pidFile);
+    } catch {
+    }
+  }
+});
+var logsCommand = new Command("logs").description("Show daemon logs").option("-n, --lines <number>", "Number of lines to show", "50").option("-f, --follow", "Follow log output").action(async (options) => {
+  const logFile = getLogFile();
+  if (!existsSync3(logFile)) {
+    logger_default.dim("No logs found.");
+    return;
+  }
+  const numLines = parseInt(options.lines, 10);
+  if (options.follow) {
+    const { spawn: spawn2 } = await import("child_process");
+    const tail = spawn2("tail", ["-f", "-n", String(numLines), logFile], {
+      stdio: "inherit"
+    });
+    tail.on("error", () => {
+      logger_default.warn("Follow mode not supported on this platform.");
+      showLogs(logFile, numLines);
+    });
+  } else {
+    showLogs(logFile, numLines);
+  }
+});
+function showLogs(logFile, numLines) {
+  const content = readFileSync3(logFile, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  const lastLines = lines.slice(-numLines);
+  lastLines.forEach((line) => console.log(line));
+}
+var serviceCommand = new Command("service").description("Manage auto-start service").addCommand(
+  new Command("install").description("Install auto-start service (LaunchAgent on macOS, systemd on Linux)").option("--no-tray", "Skip installing tray icon service").action(async (options) => {
+    logger_default.info("Installing auto-start service...");
+    const result = await installService({ includeTray: options.tray !== false });
+    if (result.success) {
+      logger_default.success("Auto-start service installed.");
+      logger_default.dim("Daemon will start automatically on login and restart on crash.");
+      if (options.tray !== false) {
+        logger_default.dim("Tray icon will appear in GUI sessions.");
+      }
+    } else {
+      logger_default.error(`Failed to install service: ${result.error}`);
+    }
+  })
+).addCommand(
+  new Command("uninstall").description("Remove auto-start service").action(async () => {
+    logger_default.info("Removing auto-start service...");
+    const result = await uninstallService();
+    if (result.success) {
+      logger_default.success("Auto-start service removed.");
+    } else {
+      logger_default.error(`Failed to remove service: ${result.error}`);
+    }
+  })
+).addCommand(
+  new Command("status").description("Show auto-start service status").action(async () => {
+    const status = getServiceStatus();
+    logger_default.blank();
+    logger_default.info(`Platform: ${status.platform}`);
+    logger_default.blank();
+    if (status.daemon.installed) {
+      logger_default.running(`Daemon service: installed${status.daemon.loaded ? " & loaded" : " (not loaded)"}`);
+    } else {
+      logger_default.stopped("Daemon service: not installed");
+    }
+    if (status.tray.installed) {
+      logger_default.running(`Tray service: installed${status.tray.loaded ? " & loaded" : " (not loaded)"}`);
+    } else {
+      logger_default.stopped("Tray service: not installed");
+    }
+    logger_default.blank();
+    if (!status.daemon.installed) {
+      logger_default.dim("Run 'skillo service install' to enable auto-start.");
+    }
+    logger_default.blank();
+  })
+);
+async function runDaemonForeground() {
+  const pidFile = getPidFile();
+  writeFileSync3(pidFile, String(process.pid));
+  logger_default.dim(`Daemon PID: ${process.pid}`);
+  logger_default.dim(`Log file: ${getLogFile()}`);
+  logger_default.blank();
+  const statusWriter = new StatusWriter();
+  const cleanup = () => {
+    logger_default.blank();
+    logger_default.info("Shutting down daemon...");
+    statusWriter.stop();
+    if (existsSync3(pidFile)) {
+      try {
+        unlinkSync3(pidFile);
+      } catch {
+      }
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const config = loadConfig();
+  const { getApiClient } = await import("./api-client-BF6GDR7Q.js");
+  const client = getApiClient();
+  if (!client.hasApiKey()) {
+    logger_default.error("Not logged in. Run 'skillo login' first.");
+    process.exit(1);
+  }
+  try {
+    const authResult = await client.authenticate();
+    const user = authResult.data?.user || authResult.user;
+    if (authResult.success && user) {
+      statusWriter.update({ user: user.name });
+      logger_default.dim(`Authenticated as: ${user.name}`);
+    }
+  } catch {
+  }
+  ensureDirectory(getDataDir());
+  ensureDirectory(getActiveSessionsDir());
+  const log = (level, msg) => {
+    if (level === "ERROR") logger_default.error(msg);
+    else if (level === "WARN") logger_default.warn(msg);
+    else logger_default.dim(msg);
+  };
+  const projects = await updateTrackedProjectsCache(client, log);
+  if (projects) statusWriter.update({ trackedProjects: projects });
+  await cleanupStaleSessions(client, log);
+  const { ClaudeWatcher } = await import("./claude-watcher-WKGBJYKN.js");
+  const watchInterval = (config.daemon?.conversationCheckInterval || 5) * 1e3;
+  const watcher = new ClaudeWatcher(client, {
+    intervalMs: watchInterval,
+    callbacks: {
+      onSync: (count) => {
+        logger_default.success(`Synced ${count} Claude prompt(s)`);
+        statusWriter.update({ claudeWatcher: { promptsSynced: count, lastSync: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        logger_default.error(`Watcher error: ${err.message}`);
+        statusWriter.update({ claudeWatcher: { lastError: err.message } });
+      },
+      log: (level, msg) => {
+        if (level === "ERROR") logger_default.error(msg);
+        else if (level === "WARN") logger_default.warn(msg);
+        else logger_default.dim(msg);
+      }
+    }
+  });
+  await watcher.start();
+  const { SkillUsageDetector } = await import("./skill-usage-detector-MSW5VWQZ.js");
+  const skillDetector = new SkillUsageDetector(client, {
+    intervalMs: 3e4,
+    callbacks: {
+      onDetection: (count) => {
+        logger_default.success(`Detected ${count} skill usage(s)`);
+        statusWriter.update({ skillDetector: { usagesDetected: count, lastDetection: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        logger_default.error(`Skill detection error: ${err.message}`);
+        statusWriter.update({ skillDetector: { lastError: err.message } });
+      },
+      log: (level, msg) => {
+        if (level === "ERROR") logger_default.error(msg);
+        else if (level === "WARN") logger_default.warn(msg);
+        else logger_default.dim(msg);
+      }
+    }
+  });
+  await skillDetector.start();
+  const { SkillInstaller } = await import("./skill-installer-F67OAOQN.js");
+  const skillInstaller = new SkillInstaller(client, {
+    intervalMs: 3e4,
+    callbacks: {
+      onInstall: (slug) => {
+        logger_default.success(`Installed skill: ${slug}`);
+        statusWriter.update({ skillInstaller: { lastInstall: slug, lastAction: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onUninstall: (slug) => {
+        logger_default.success(`Uninstalled skill: ${slug}`);
+        statusWriter.update({ skillInstaller: { lastUninstall: slug, lastAction: (/* @__PURE__ */ new Date()).toISOString(), lastError: null } });
+      },
+      onError: (err) => {
+        logger_default.error(`Skill installer error: ${err.message}`);
+        statusWriter.update({ skillInstaller: { lastError: err.message } });
+      },
+      log: (level, msg) => {
+        if (level === "ERROR") logger_default.error(msg);
+        else if (level === "WARN") logger_default.warn(msg);
+        else logger_default.dim(msg);
+      }
+    }
+  });
+  await skillInstaller.start();
+  statusWriter.start();
+  setInterval(async () => {
+    const updated = await updateTrackedProjectsCache(client, log);
+    if (updated) statusWriter.update({ trackedProjects: updated });
+  }, 6e4);
+  setInterval(() => cleanupStaleSessions(client, log), 3e5);
+  logger_default.success("Daemon is running. Watching Claude conversations and skill usage...");
+  await new Promise(() => {
+  });
+}
+
+export {
+  installService,
+  getServiceStatus,
+  isDaemonRunning,
+  startDaemonProcess,
+  isTrayRunning,
+  startTrayProcess,
+  ensureLoggedIn,
+  startCommand,
+  stopCommand,
+  logsCommand,
+  serviceCommand
+};
+//# sourceMappingURL=chunk-XLJGCOVT.js.map