@gowelle/stint-agent 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 import {
   commitQueue,
+  websocketService
+} from "./chunk-IJUJ6NEL.js";
+import {
+  apiService
+} from "./chunk-W4JGOGR7.js";
+import {
   getPidFilePath,
   gitService,
   isProcessRunning,
@@ -8,18 +14,17 @@ import {
   projectService,
   spawnDetached,
   validatePidFile
-} from "./chunk-OHOFKJL7.js";
+} from "./chunk-FBQA4K5J.js";
 import {
-  apiService,
   authService,
   config,
   logger
-} from "./chunk-IAERVP6F.js";
+} from "./chunk-RHMTZK2J.js";
 
 // src/index.ts
 import "dotenv/config";
 import { Command } from "commander";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 
 // src/commands/login.ts
 import open from "open";
@@ -609,10 +614,22 @@ import process4 from "process";
 import path2 from "path";
 import os from "os";
 function registerStatusCommand(program2) {
-  program2.command("status").description("Show linked project and connection status").action(async () => {
+  program2.command("status").description("Show linked project and connection status").option("-d, --dashboard", "Launch interactive TUI dashboard").action(async (options) => {
+    const cwd = process4.cwd();
+    if (options.dashboard) {
+      try {
+        const { render } = await import("ink");
+        const { createElement } = await import("react");
+        const { StatusDashboard } = await import("./StatusDashboard-7ZIGEOQ4.js");
+        render(createElement(StatusDashboard, { cwd }));
+        return;
+      } catch (error) {
+        console.error(chalk6.red(`Failed to start dashboard: ${error.message}`));
+        process4.exit(1);
+      }
+    }
     const spinner = ora6("Gathering status...").start();
     try {
-      const cwd = process4.cwd();
       const linkedProject = await projectService.getLinkedProject(cwd);
       const user = await authService.validateToken();
       spinner.stop();
@@ -705,13 +722,24 @@ function registerSyncCommand(program2) {
         console.log(chalk7.gray('Run "stint link" first to link this directory.\n'));
         process5.exit(1);
       }
-      spinner.text = "Gathering repository information...";
+      spinner.text = "Analyzing repository...";
+      const status = await gitService.getStatus(cwd);
+      const totalFiles = status.staged.length + status.unstaged.length + status.untracked.length;
+      spinner.text = `Found ${totalFiles} files to analyze...`;
+      spinner.text = "Getting branch information...";
       const repoInfo = await gitService.getRepoInfo(cwd);
-      spinner.text = "Syncing with server...";
-      await apiService.syncProject(linkedProject.projectId, repoInfo);
-      spinner.succeed("Sync completed successfully!");
-      console.log(chalk7.green("\n\u2713 Repository information synced"));
+      spinner.text = "Preparing sync payload...";
+      const syncSpinner = ora7("Connecting to server...").start();
+      try {
+        await apiService.syncProject(linkedProject.projectId, repoInfo);
+        syncSpinner.succeed("Server sync completed");
+      } catch (error) {
+        syncSpinner.fail("Server sync failed");
+        throw error;
+      }
+      console.log(chalk7.green("\n\u2713 Repository sync completed"));
       console.log(chalk7.gray("\u2500".repeat(50)));
+      console.log(`${chalk7.bold("Files:")}       ${totalFiles} total (${status.staged.length} staged, ${status.unstaged.length} modified, ${status.untracked.length} untracked)`);
       console.log(`${chalk7.bold("Project ID:")}  ${linkedProject.projectId}`);
       console.log(`${chalk7.bold("Branch:")}      ${repoInfo.currentBranch}`);
       console.log(`${chalk7.bold("Commit:")}      ${repoInfo.lastCommitSha.substring(0, 7)} - ${repoInfo.lastCommitMessage}`);
@@ -734,11 +762,160 @@ import ora8 from "ora";
 import chalk8 from "chalk";
 import fs from "fs";
 import path3 from "path";
-import os2 from "os";
+import os3 from "os";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
+import { createInterface } from "readline";
+
+// src/utils/monitor.ts
+import os2 from "os";
+import { readFileSync } from "fs";
+import { execSync } from "child_process";
+function getProcessStats(pid) {
+  try {
+    const platform = os2.platform();
+    if (platform === "linux") {
+      return getLinuxStats(pid);
+    } else if (platform === "darwin") {
+      return getMacStats(pid);
+    } else if (platform === "win32") {
+      return getWindowsStats(pid);
+    }
+    throw new Error(`Unsupported platform: ${platform}`);
+  } catch (error) {
+    logger.error("monitor", `Failed to get process stats for PID ${pid}`, error);
+    return null;
+  }
+}
+function getLinuxStats(pid) {
+  const statContent = readFileSync(`/proc/${pid}/stat`, "utf8");
+  const statParts = statContent.split(" ");
+  const statusContent = readFileSync(`/proc/${pid}/status`, "utf8");
+  const vmRSS = parseInt(statusContent.match(/VmRSS:\s+(\d+)/)?.[1] || "0");
+  readFileSync("/proc/stat", "utf8");
+  const utime = parseInt(statParts[13]);
+  const stime = parseInt(statParts[14]);
+  const starttime = parseInt(statParts[21]);
+  const threads = parseInt(statParts[19]);
+  const totalTime = utime + stime;
+  const seconds = os2.uptime() - starttime / os2.cpus().length;
+  const cpuPercent = totalTime / seconds * 100 / os2.cpus().length;
+  return {
+    pid,
+    cpuPercent: Math.round(cpuPercent * 100) / 100,
+    memoryMB: Math.round(vmRSS / 1024 * 100) / 100,
+    uptime: Math.round(seconds),
+    threads
+  };
+}
+function getMacStats(pid) {
+  const psOutput = execSync(`ps -p ${pid} -o %cpu,%mem,etime,thcount`).toString();
+  const [cpu, mem, etime, threads] = psOutput.split("\n")[1].trim().split(/\s+/);
+  const uptimeSeconds = parseElapsedTime(etime);
+  const totalMem = os2.totalmem() / (1024 * 1024);
+  const memoryMB = parseFloat(mem) / 100 * totalMem;
+  return {
+    pid,
+    cpuPercent: Math.round(parseFloat(cpu) * 100) / 100,
+    memoryMB: Math.round(memoryMB * 100) / 100,
+    uptime: uptimeSeconds,
+    threads: parseInt(threads)
+  };
+}
+function getWindowsStats(pid) {
+  const wmicOutput = execSync(
+    `wmic path Win32_PerfFormattedData_PerfProc_Process WHERE IDProcess=${pid} get PercentProcessorTime,WorkingSetPrivate,ElapsedTime,ThreadCount /format:csv`
+  ).toString();
+  const [, , data] = wmicOutput.trim().split("\n");
+  if (!data) {
+    throw new Error(`Process ${pid} not found`);
+  }
+  const [, cpu, workingSet, elapsedTime, threads] = data.split(",");
+  return {
+    pid,
+    cpuPercent: Math.round(parseInt(cpu) / os2.cpus().length * 100) / 100,
+    memoryMB: Math.round(parseInt(workingSet) / (1024 * 1024) * 100) / 100,
+    uptime: Math.round(parseInt(elapsedTime) / 1e3),
+    threads: parseInt(threads)
+  };
+}
+function parseElapsedTime(etime) {
+  const parts = etime.split("-");
+  const timeStr = parts[parts.length - 1];
+  const timeParts = timeStr.split(":");
+  let seconds = 0;
+  if (timeParts.length === 3) {
+    seconds = parseInt(timeParts[0]) * 3600 + parseInt(timeParts[1]) * 60 + parseInt(timeParts[2]);
+  } else if (timeParts.length === 2) {
+    seconds = parseInt(timeParts[0]) * 60 + parseInt(timeParts[1]);
+  } else {
+    seconds = parseInt(timeParts[0]);
+  }
+  if (parts.length === 2) {
+    seconds += parseInt(parts[0]) * 86400;
+  }
+  return seconds;
+}
+
+// src/commands/daemon.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
+function parseLogLine(line) {
+  const match = line.match(/\[(.*?)\] (\w+)\s+\[(.*?)\] (.*)/);
+  if (!match) return null;
+  const [, timestamp, level, category, message] = match;
+  return {
+    timestamp: new Date(timestamp),
+    level,
+    category,
+    message
+  };
+}
+function shouldIncludeLine(parsed, filter) {
+  if (!parsed) return false;
+  if (filter.level && filter.level.toUpperCase() !== parsed.level) {
+    return false;
+  }
+  if (filter.category && !parsed.category.toLowerCase().includes(filter.category.toLowerCase())) {
+    return false;
+  }
+  if (filter.since && parsed.timestamp < filter.since) {
+    return false;
+  }
+  if (filter.until && parsed.timestamp > filter.until) {
+    return false;
+  }
+  if (filter.search && !parsed.message.toLowerCase().includes(filter.search.toLowerCase())) {
+    return false;
+  }
+  return true;
+}
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = seconds % 60;
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+  return parts.join(" ");
+}
+function colorizeLevel(level) {
+  switch (level.trim()) {
+    case "ERROR":
+      return chalk8.red(level);
+    case "WARN":
+      return chalk8.yellow(level);
+    case "INFO":
+      return chalk8.blue(level);
+    case "DEBUG":
+      return chalk8.gray(level);
+    default:
+      return level;
+  }
+}
 function registerDaemonCommands(program2) {
   const daemon = program2.command("daemon").description("Manage the Stint daemon");
   daemon.command("start").description("Start the daemon in the background").action(async () => {
@@ -774,7 +951,7 @@ function registerDaemonCommands(program2) {
       console.log(chalk8.green(`
 \u2713 Daemon is running in the background`));
       console.log(chalk8.gray(`PID: ${daemonPid}`));
-      console.log(chalk8.gray(`Logs: ${path3.join(os2.homedir(), ".config", "stint", "logs", "daemon.log")}
+      console.log(chalk8.gray(`Logs: ${path3.join(os3.homedir(), ".config", "stint", "logs", "daemon.log")}
 `));
       logger.success("daemon", `Daemon started with PID ${daemonPid}`);
     } catch (error) {
@@ -835,7 +1012,16 @@ function registerDaemonCommands(program2) {
         console.log(`${chalk8.bold("Status:")}      ${chalk8.green("\u2713 Running")}`);
         console.log(`${chalk8.bold("PID:")}         ${pid}`);
         console.log(`${chalk8.bold("PID File:")}    ${getPidFilePath()}`);
-        console.log(`${chalk8.bold("Logs:")}        ${path3.join(os2.homedir(), ".config", "stint", "logs", "daemon.log")}`);
+        console.log(`${chalk8.bold("Logs:")}        ${path3.join(os3.homedir(), ".config", "stint", "logs", "daemon.log")}`);
+        const stats = await getProcessStats(pid);
+        if (stats) {
+          console.log(chalk8.blue("\n\u{1F4CA} Resource Usage:"));
+          console.log(chalk8.gray("\u2500".repeat(50)));
+          console.log(`${chalk8.bold("CPU:")}         ${stats.cpuPercent}%`);
+          console.log(`${chalk8.bold("Memory:")}      ${stats.memoryMB} MB`);
+          console.log(`${chalk8.bold("Threads:")}     ${stats.threads}`);
+          console.log(`${chalk8.bold("Uptime:")}      ${formatUptime(stats.uptime)}`);
+        }
       } else {
         console.log(`${chalk8.bold("Status:")}      ${chalk8.yellow("Not running")}`);
         console.log(chalk8.gray('Run "stint daemon start" to start the daemon.'));
@@ -847,36 +1033,6 @@ function registerDaemonCommands(program2) {
       logger.error("daemon", "Status command failed", error);
       console.error(chalk8.red(`
 \u2716 Error: ${error.message}
-`));
-      process.exit(1);
-    }
-  });
-  daemon.command("logs").description("Tail daemon logs").option("-n, --lines <number>", "Number of lines to show", "50").action(async (options) => {
-    try {
-      const logFile = path3.join(os2.homedir(), ".config", "stint", "logs", "daemon.log");
-      if (!fs.existsSync(logFile)) {
-        console.log(chalk8.yellow("\n\u26A0 No daemon logs found."));
-        console.log(chalk8.gray("The daemon has not been started yet.\n"));
-        return;
-      }
-      const lines = parseInt(options.lines, 10);
-      const content = fs.readFileSync(logFile, "utf8");
-      const logLines = content.split("\n").filter((line) => line.trim());
-      const lastLines = logLines.slice(-lines);
-      console.log(chalk8.blue(`
-\u{1F4CB} Last ${lastLines.length} lines of daemon logs:
-`));
-      console.log(chalk8.gray("\u2500".repeat(80)));
-      lastLines.forEach((line) => console.log(line));
-      console.log(chalk8.gray("\u2500".repeat(80)));
-      console.log(chalk8.gray(`
-Log file: ${logFile}`));
-      console.log(chalk8.gray('Use "tail -f" to follow logs in real-time.\n'));
-      logger.info("daemon", "Logs command executed");
-    } catch (error) {
-      logger.error("daemon", "Logs command failed", error);
-      console.error(chalk8.red(`
-\u2716 Error: ${error.message}
 `));
       process.exit(1);
     }
@@ -925,6 +1081,119 @@ Log file: ${logFile}`));
       throw error;
     }
   });
+  daemon.command("logs").description("View and filter daemon logs").option("-l, --level <level>", "Filter by log level (INFO, WARN, ERROR, DEBUG)").option("-c, --category <category>", "Filter by log category").option("-s, --since <date>", 'Show logs since date/time (ISO format or relative time like "1h", "2d")').option("-u, --until <date>", 'Show logs until date/time (ISO format or relative time like "1h", "2d")').option("--search <text>", "Search for specific text in log messages").option("-f, --follow", "Follow log output in real time").option("-n, --lines <number>", "Number of lines to show", "50").action(async (command) => {
+    const spinner = ora8("Loading logs...").start();
+    try {
+      const logPath = path3.join(os3.homedir(), ".config", "stint", "logs", "agent.log");
+      if (!fs.existsSync(logPath)) {
+        spinner.fail("No logs found");
+        return;
+      }
+      const now = /* @__PURE__ */ new Date();
+      let since;
+      let until;
+      if (command.since) {
+        if (command.since.match(/^\d+[hdw]$/)) {
+          const value = parseInt(command.since.slice(0, -1));
+          const unit = command.since.slice(-1);
+          const ms = value * {
+            h: 60 * 60 * 1e3,
+            d: 24 * 60 * 60 * 1e3,
+            w: 7 * 24 * 60 * 60 * 1e3
+          }[unit];
+          since = new Date(now.getTime() - ms);
+        } else {
+          since = new Date(command.since);
+        }
+      }
+      if (command.until) {
+        if (command.until.match(/^\d+[hdw]$/)) {
+          const value = parseInt(command.until.slice(0, -1));
+          const unit = command.until.slice(-1);
+          const ms = value * {
+            h: 60 * 60 * 1e3,
+            d: 24 * 60 * 60 * 1e3,
+            w: 7 * 24 * 60 * 60 * 1e3
+          }[unit];
+          until = new Date(now.getTime() - ms);
+        } else {
+          until = new Date(command.until);
+        }
+      }
+      const filter = {
+        level: command.level?.toUpperCase(),
+        category: command.category,
+        since,
+        until,
+        search: command.search
+      };
+      const maxLines = command.follow ? 10 : parseInt(command.lines);
+      const lines = [];
+      const fileStream = fs.createReadStream(logPath, { encoding: "utf8" });
+      const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+      spinner.stop();
+      for await (const line of rl) {
+        const parsed = parseLogLine(line);
+        if (parsed && shouldIncludeLine(parsed, filter)) {
+          lines.push(line);
+          if (lines.length > maxLines && !command.follow) {
+            lines.shift();
+          }
+        }
+      }
+      if (lines.length === 0) {
+        console.log(chalk8.yellow("\nNo matching logs found\n"));
+        return;
+      }
+      console.log();
+      lines.forEach((line) => {
+        const parsed = parseLogLine(line);
+        if (parsed) {
+          const { timestamp, level, category, message } = parsed;
+          console.log(
+            chalk8.gray(`[${timestamp.toISOString()}]`),
+            colorizeLevel(level.padEnd(5)),
+            chalk8.cyan(`[${category}]`),
+            message
+          );
+        }
+      });
+      console.log();
+      if (command.follow) {
+        console.log(chalk8.gray("Following log output (Ctrl+C to exit)...\n"));
+        const tail = fs.watch(logPath, (eventType) => {
+          if (eventType === "change") {
+            const newLines = fs.readFileSync(logPath, "utf8").split("\n").slice(-1);
+            newLines.forEach((line) => {
+              if (!line) return;
+              const parsed = parseLogLine(line);
+              if (parsed && shouldIncludeLine(parsed, filter)) {
+                const { timestamp, level, category, message } = parsed;
+                console.log(
+                  chalk8.gray(`[${timestamp.toISOString()}]`),
+                  colorizeLevel(level.padEnd(5)),
+                  chalk8.cyan(`[${category}]`),
+                  message
+                );
+              }
+            });
+          }
+        });
+        process.on("SIGINT", () => {
+          tail.close();
+          console.log(chalk8.gray("\nStopped following logs\n"));
+          process.exit(0);
+        });
+      }
+    } catch (error) {
+      spinner.fail("Failed to read logs");
+      logger.error("daemon", "Logs command failed", error);
+      console.error(chalk8.red(`
+\u2716 Error: ${error.message}
+`));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/commit.ts
@@ -1022,7 +1291,7 @@ function registerCommitCommands(program2) {
         console.log(chalk9.yellow("\nCommit cancelled.\n"));
         return;
       }
-      const execSpinner = ora9("Executing commit...").start();
+      const execSpinner = ora9("Preparing commit...").start();
       const project = {
         id: linkedProject.projectId,
         name: "Current Project",
@@ -1030,14 +1299,24 @@ function registerCommitCommands(program2) {
         createdAt: "",
         updatedAt: ""
       };
-      const sha = await commitQueue.executeCommit(commit, project);
+      const sha = await commitQueue.executeCommit(commit, project, (stage) => {
+        execSpinner.text = stage;
+      });
       execSpinner.succeed("Commit executed successfully!");
       console.log(chalk9.green("\n\u2713 Commit executed"));
       console.log(chalk9.gray("\u2500".repeat(50)));
       console.log(`${chalk9.bold("Commit ID:")}  ${commit.id}`);
       console.log(`${chalk9.bold("Message:")}    ${commit.message}`);
       console.log(`${chalk9.bold("SHA:")}        ${sha}`);
+      console.log(`${chalk9.bold("Files:")}      ${status.staged.length} files committed`);
       console.log();
+      if (status.staged.length > 0) {
+        console.log(chalk9.gray("Committed files:"));
+        status.staged.forEach((file) => {
+          console.log(chalk9.green(`  + ${file}`));
+        });
+        console.log();
+      }
       logger.success("commit", `Executed commit ${commit.id} -> ${sha}`);
     } catch (error) {
       if (ora9().isSpinning) {
@@ -1066,7 +1345,7 @@ import ora10 from "ora";
 import chalk10 from "chalk";
 import fs2 from "fs";
 import path4 from "path";
-import os3 from "os";
+import os4 from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -1094,8 +1373,8 @@ async function uninstallWindows() {
 }
 function getMacPlistContent() {
   const scriptPath = process.argv[1];
-  const logPath = path4.join(os3.homedir(), ".config", "stint", "logs", "launchd.log");
-  const errorPath = path4.join(os3.homedir(), ".config", "stint", "logs", "launchd.error.log");
+  const logPath = path4.join(os4.homedir(), ".config", "stint", "logs", "launchd.log");
+  const errorPath = path4.join(os4.homedir(), ".config", "stint", "logs", "launchd.error.log");
   const logDir = path4.dirname(logPath);
   if (!fs2.existsSync(logDir)) {
     fs2.mkdirSync(logDir, { recursive: true });
@@ -1129,7 +1408,7 @@ function getMacPlistContent() {
 }
 async function installMac() {
   const plistContent = getMacPlistContent();
-  const launchAgentsDir = path4.join(os3.homedir(), "Library", "LaunchAgents");
+  const launchAgentsDir = path4.join(os4.homedir(), "Library", "LaunchAgents");
   const plistPath = path4.join(launchAgentsDir, MAC_PLIST_NAME);
   if (!fs2.existsSync(launchAgentsDir)) {
     fs2.mkdirSync(launchAgentsDir, { recursive: true });
@@ -1142,7 +1421,7 @@ async function installMac() {
   await execAsync(`launchctl load "${plistPath}"`);
 }
 async function uninstallMac() {
-  const launchAgentsDir = path4.join(os3.homedir(), "Library", "LaunchAgents");
+  const launchAgentsDir = path4.join(os4.homedir(), "Library", "LaunchAgents");
   const plistPath = path4.join(launchAgentsDir, MAC_PLIST_NAME);
   if (fs2.existsSync(plistPath)) {
     try {
@@ -1170,7 +1449,7 @@ StandardError=journal
 WantedBy=default.target`;
 }
 async function installLinux() {
-  const systemdDir = path4.join(os3.homedir(), ".config", "systemd", "user");
+  const systemdDir = path4.join(os4.homedir(), ".config", "systemd", "user");
   const servicePath = path4.join(systemdDir, SYSTEMD_SERVICE_NAME);
   if (!fs2.existsSync(systemdDir)) {
     fs2.mkdirSync(systemdDir, { recursive: true });
@@ -1182,7 +1461,7 @@ async function installLinux() {
   await execAsync(`systemctl --user start ${SYSTEMD_SERVICE_NAME}`);
 }
 async function uninstallLinux() {
-  const systemdDir = path4.join(os3.homedir(), ".config", "systemd", "user");
+  const systemdDir = path4.join(os4.homedir(), ".config", "systemd", "user");
   const servicePath = path4.join(systemdDir, SYSTEMD_SERVICE_NAME);
   try {
     await execAsync(`systemctl --user stop ${SYSTEMD_SERVICE_NAME}`);
@@ -1206,7 +1485,7 @@ function registerInstallCommand(program2) {
         process.exit(1);
       }
       spinner.text = "Installing startup agent...";
-      const platform = os3.platform();
+      const platform = os4.platform();
       if (platform === "win32") {
         await installWindows();
       } else if (platform === "darwin") {
@@ -1242,7 +1521,7 @@ function registerUninstallCommand(program2) {
   program2.command("uninstall").description("Remove stint agent from system startup").action(async () => {
     const spinner = ora10("Removing startup agent...").start();
     try {
-      const platform = os3.platform();
+      const platform = os4.platform();
       if (platform === "win32") {
         await uninstallWindows();
       } else if (platform === "darwin") {
@@ -1271,14 +1550,68 @@ import ora11 from "ora";
 import chalk11 from "chalk";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
+import { join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2 } from "path";
 var execAsync2 = promisify2(exec2);
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+function getChannelConfig() {
+  try {
+    const packagePath = join(__dirname2, "..", "..", "package.json");
+    const packageJson = JSON.parse(readFileSync2(packagePath, "utf-8"));
+    return packageJson.stint;
+  } catch {
+    return {
+      channels: {
+        stable: {
+          pattern: "^\\d+\\.\\d+\\.\\d+$",
+          description: "Production-ready releases"
+        }
+      },
+      defaultChannel: "stable"
+    };
+  }
+}
+function getVersionPattern(channel) {
+  const config2 = getChannelConfig();
+  return config2.channels[channel]?.pattern || config2.channels[config2.defaultChannel].pattern;
+}
+async function getLatestVersionForChannel(channel) {
+  const pattern = getVersionPattern(channel);
+  const regex = new RegExp(pattern);
+  const { stdout } = await execAsync2("npm view @gowelle/stint-agent versions --json");
+  const versions = JSON.parse(stdout);
+  const channelVersions = versions.filter((v) => regex.test(v)).sort((a, b) => {
+    const [aMajor, aMinor, aPatch] = a.split(".").map((part) => parseInt(part.split("-")[0]));
+    const [bMajor, bMinor, bPatch] = b.split(".").map((part) => parseInt(part.split("-")[0]));
+    if (aMajor !== bMajor) return bMajor - aMajor;
+    if (aMinor !== bMinor) return bMinor - aMinor;
+    return bPatch - aPatch;
+  });
+  if (channelVersions.length === 0) {
+    throw new Error(`No versions found for channel: ${channel}`);
+  }
+  return channelVersions[0];
+}
 function registerUpdateCommand(program2) {
-  program2.command("update").description("Update stint agent to the latest version").action(async () => {
+  program2.command("update").description("Update stint agent to the latest version").option("-c, --channel <channel>", "Release channel (stable, beta, nightly)").action(async (command) => {
     const spinner = ora11("Checking for updates...").start();
     try {
       const currentVersion = program2.version();
-      const { stdout: latestVersion } = await execAsync2("npm view @gowelle/stint-agent version");
-      const cleanLatestVersion = latestVersion.trim();
+      const config2 = getChannelConfig();
+      const channel = (command.opts().channel || config2.defaultChannel).toLowerCase();
+      if (!config2.channels[channel]) {
+        spinner.fail(`Invalid channel: ${channel}`);
+        console.log(chalk11.gray("\nAvailable channels:"));
+        Object.entries(config2.channels).forEach(([name, info]) => {
+          console.log(chalk11.gray(`  ${name.padEnd(10)} ${info.description}`));
+        });
+        console.log();
+        process.exit(1);
+      }
+      spinner.text = `Checking for updates in ${channel} channel...`;
+      const cleanLatestVersion = await getLatestVersionForChannel(channel);
       if (currentVersion === cleanLatestVersion) {
         spinner.succeed("Already up to date");
         console.log(chalk11.gray(`
@@ -1289,7 +1622,7 @@ Current version: ${currentVersion}`));
       }
       spinner.info(`Update available: ${currentVersion} \u2192 ${cleanLatestVersion}`);
       spinner.text = "Installing update...";
-      await execAsync2("npm install -g @gowelle/stint-agent@latest");
+      await execAsync2(`npm install -g @gowelle/stint-agent@${cleanLatestVersion}`);
       spinner.succeed(`Updated to version ${cleanLatestVersion}`);
       const { valid, pid } = validatePidFile();
       if (valid && pid) {
@@ -1327,20 +1660,193 @@ Current version: ${currentVersion}`));
   });
 }
 
+// src/commands/doctor.ts
+import ora12 from "ora";
+import chalk12 from "chalk";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import process7 from "process";
+var execAsync3 = promisify3(exec3);
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Run diagnostics to check environment health").action(async () => {
+    const spinner = ora12("Running diagnostics...").start();
+    let hasErrors = false;
+    try {
+      const checks = [
+        {
+          name: "Git Installation",
+          check: async () => {
+            try {
+              const { stdout } = await execAsync3("git --version");
+              return {
+                success: true,
+                message: `Git ${stdout.trim()} found`
+              };
+            } catch {
+              return {
+                success: false,
+                message: "Git not found in PATH",
+                details: [
+                  "Please install Git from https://git-scm.com",
+                  "Ensure git is added to your system PATH"
+                ]
+              };
+            }
+          }
+        },
+        {
+          name: "Git Configuration",
+          check: async () => {
+            try {
+              const { stdout: userName } = await execAsync3("git config --global user.name");
+              const { stdout: userEmail } = await execAsync3("git config --global user.email");
+              if (!userName.trim() || !userEmail.trim()) {
+                return {
+                  success: false,
+                  message: "Git user configuration missing",
+                  details: [
+                    'Run: git config --global user.name "Your Name"',
+                    'Run: git config --global user.email "your@email.com"'
+                  ]
+                };
+              }
+              return {
+                success: true,
+                message: `Git configured for ${userName.trim()} <${userEmail.trim()}>`
+              };
+            } catch {
+              return {
+                success: false,
+                message: "Failed to read Git configuration"
+              };
+            }
+          }
+        },
+        {
+          name: "Authentication",
+          check: async () => {
+            try {
+              const user = await authService.validateToken();
+              if (!user) {
+                return {
+                  success: false,
+                  message: "Not authenticated",
+                  details: ['Run "stint login" to authenticate']
+                };
+              }
+              return {
+                success: true,
+                message: `Authenticated as ${user.email}`
+              };
+            } catch {
+              return {
+                success: false,
+                message: "Authentication validation failed",
+                details: ['Run "stint login" to re-authenticate']
+              };
+            }
+          }
+        },
+        {
+          name: "API Connectivity",
+          check: async () => {
+            try {
+              await apiService.ping();
+              return {
+                success: true,
+                message: "API connection successful"
+              };
+            } catch (error) {
+              return {
+                success: false,
+                message: "API connection failed",
+                details: [error.message]
+              };
+            }
+          }
+        },
+        {
+          name: "WebSocket Connectivity",
+          check: async () => {
+            try {
+              await websocketService.connect();
+              const isConnected = websocketService.isConnected();
+              websocketService.disconnect();
+              if (!isConnected) {
+                return {
+                  success: false,
+                  message: "WebSocket connection failed",
+                  details: ["Connection established but not ready"]
+                };
+              }
+              return {
+                success: true,
+                message: "WebSocket connection successful"
+              };
+            } catch (error) {
+              return {
+                success: false,
+                message: "WebSocket connection failed",
+                details: [error.message]
+              };
+            }
+          }
+        }
+      ];
+      console.log(chalk12.blue("\n\u{1F50D} Running environment diagnostics...\n"));
+      for (const check of checks) {
+        spinner.text = `Checking ${check.name.toLowerCase()}...`;
+        try {
+          const result = await check.check();
+          if (result.success) {
+            console.log(`${chalk12.green("\u2713")} ${chalk12.bold(check.name)}: ${result.message}`);
+          } else {
+            hasErrors = true;
+            console.log(`${chalk12.red("\u2716")} ${chalk12.bold(check.name)}: ${result.message}`);
+            if (result.details) {
+              result.details.forEach((detail) => {
+                console.log(chalk12.gray(`   ${detail}`));
+              });
+            }
+          }
+        } catch (error) {
+          hasErrors = true;
+          console.log(`${chalk12.red("\u2716")} ${chalk12.bold(check.name)}: Check failed - ${error.message}`);
+        }
+      }
+      spinner.stop();
+      console.log();
+      if (hasErrors) {
+        console.log(chalk12.yellow("Some checks failed. Please address the issues above."));
+        process7.exit(1);
+      } else {
+        console.log(chalk12.green("All checks passed! Your environment is healthy."));
+      }
+    } catch (error) {
+      spinner.fail("Diagnostics failed");
+      logger.error("doctor", "Diagnostics failed", error);
+      console.error(chalk12.red(`
+\u2716 Error: ${error.message}
+`));
+      process7.exit(1);
+    }
+  });
+}
+
 // src/index.ts
-var AGENT_VERSION = "1.1.0";
+var AGENT_VERSION = "1.2.0";
 var program = new Command();
 program.name("stint").description("Stint Agent - Local daemon for Stint Project Assistant").version(AGENT_VERSION, "-v, --version", "output the current version").addHelpText("after", `
-${chalk12.bold("Examples:")}
-  ${chalk12.cyan("$")} stint login                 ${chalk12.gray("# Authenticate with Stint")}
-  ${chalk12.cyan("$")} stint install               ${chalk12.gray("# Install agent to run on startup")}
-  ${chalk12.cyan("$")} stint link                  ${chalk12.gray("# Link current directory to a project")}
-  ${chalk12.cyan("$")} stint daemon start          ${chalk12.gray("# Start background daemon")}
-  ${chalk12.cyan("$")} stint status                ${chalk12.gray("# Check status")}
-  ${chalk12.cyan("$")} stint commits               ${chalk12.gray("# List pending commits")}
+${chalk13.bold("Examples:")}
+  ${chalk13.cyan("$")} stint login                 ${chalk13.gray("# Authenticate with Stint")}
+  ${chalk13.cyan("$")} stint install               ${chalk13.gray("# Install agent to run on startup")}
+  ${chalk13.cyan("$")} stint link                  ${chalk13.gray("# Link current directory to a project")}
+  ${chalk13.cyan("$")} stint daemon start          ${chalk13.gray("# Start background daemon")}
+  ${chalk13.cyan("$")} stint status                ${chalk13.gray("# Check status")}
+  ${chalk13.cyan("$")} stint commits               ${chalk13.gray("# List pending commits")}
 
-${chalk12.bold("Documentation:")}
-  For more information, visit: ${chalk12.blue("https://stint.codes/docs")}
+${chalk13.bold("Documentation:")}
+  For more information, visit: ${chalk13.blue("https://stint.codes/docs")}
     `);
 registerLoginCommand(program);
 registerLogoutCommand(program);
@@ -1354,6 +1860,7 @@ registerCommitCommands(program);
 registerInstallCommand(program);
 registerUninstallCommand(program);
 registerUpdateCommand(program);
+registerDoctorCommand(program);
 program.exitOverride();
 try {
   await program.parseAsync(process.argv);
@@ -1361,7 +1868,7 @@ try {
   const commanderError = error;
   if (commanderError.code !== "commander.help" && commanderError.code !== "commander.version" && commanderError.code !== "commander.helpDisplayed") {
     logger.error("cli", "Command execution failed", error);
-    console.error(chalk12.red(`
+    console.error(chalk13.red(`
 \u2716 Error: ${error.message}
 `));
     process.exit(1);