npm - @gowelle/stint-agent - Versions diffs - 1.0.0 - Mend

@gowelle/stint-agent 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,854 @@
+#!/usr/bin/env node
+import {
+  commitQueue,
+  getPidFilePath,
+  gitService,
+  isProcessRunning,
+  killProcess,
+  projectService,
+  spawnDetached,
+  validatePidFile
+} from "./chunk-PPODHVVP.js";
+import {
+  apiService,
+  authService,
+  config,
+  logger
+} from "./chunk-5DWSNHS6.js";
+// src/index.ts
+import "dotenv/config";
+import { Command } from "commander";
+import chalk10 from "chalk";
+// src/commands/login.ts
+import open from "open";
+import ora from "ora";
+import chalk from "chalk";
+import { createServer } from "http";
+import { URL } from "url";
+function escapeHtml(text) {
+  if (!text) {
+    return "";
+  }
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function startCallbackServer(expectedState, timeoutMs = 5 * 60 * 1e3) {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    let callbackResolve;
+    let callbackReject;
+    let timeout;
+    const callbackPromise = new Promise((resolve2, reject2) => {
+      callbackResolve = resolve2;
+      callbackReject = reject2;
+    });
+    server.on("request", (req, res) => {
+      if (req.url?.startsWith("/auth/callback")) {
+        try {
+          const url = new URL(req.url, `http://${req.headers.host}`);
+          const token = url.searchParams.get("token");
+          const state = url.searchParams.get("state");
+          const error = url.searchParams.get("error");
+          if (error) {
+            const errorDescription = url.searchParams.get("error_description") || error;
+            const escapedError = escapeHtml(errorDescription);
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+                            <html>
+                                <head><title>Authentication Failed</title></head>
+                                <body>
+                                    <h1>Authentication Failed</h1>
+                                    <p>${escapedError}</p>
+                                    <p>You can close this window.</p>
+                                </body>
+                            </html>
+                        `);
+            callbackReject(new Error(`OAuth error: ${errorDescription}`));
+            return;
+          }
+          if (state !== expectedState) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+                            <html>
+                                <head><title>Authentication Failed</title></head>
+                                <body>
+                                    <h1>Authentication Failed</h1>
+                                    <p>Invalid state parameter. Security validation failed.</p>
+                                    <p>You can close this window.</p>
+                                </body>
+                            </html>
+                        `);
+            callbackReject(new Error("State parameter mismatch"));
+            return;
+          }
+          if (!token) {
+            res.writeHead(400, { "Content-Type": "text/html" });
+            res.end(`
+                            <html>
+                                <head><title>Authentication Failed</title></head>
+                                <body>
+                                    <h1>Authentication Failed</h1>
+                                    <p>No token provided in callback.</p>
+                                    <p>You can close this window.</p>
+                                </body>
+                            </html>
+                        `);
+            callbackReject(new Error("No token in callback"));
+            return;
+          }
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+                        <html>
+                            <head><title>Authentication Successful</title></head>
+                            <body>
+                                <h1>Authentication Successful!</h1>
+                                <p>You have been successfully authenticated. You can close this window.</p>
+                            </body>
+                        </html>
+                    `);
+          callbackResolve(token);
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(`
+                        <html>
+                            <head><title>Error</title></head>
+                            <body>
+                                <h1>Error</h1>
+                                <p>An error occurred processing the callback.</p>
+                                <p>You can close this window.</p>
+                            </body>
+                        </html>
+                    `);
+          callbackReject(error);
+        }
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      }
+    });
+    server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new Error("Port is already in use"));
+      } else {
+        reject(error);
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = address.port;
+      timeout = setTimeout(() => {
+        server.close();
+        callbackReject(new Error("Authentication timeout: No callback received within 5 minutes"));
+      }, timeoutMs);
+      callbackPromise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout)).finally(() => {
+        setTimeout(() => {
+          server.close();
+        }, 100);
+      });
+      resolve({
+        server,
+        port,
+        promise: callbackPromise
+      });
+    });
+  });
+}
+function registerLoginCommand(program2) {
+  program2.command("login").description("Authenticate with Stint").action(async () => {
+    const spinner = ora("Starting authentication server...").start();
+    try {
+      const state = Math.random().toString(36).substring(7);
+      const machineId = authService.getMachineId();
+      const machineName = authService.getMachineName();
+      spinner.text = "Starting callback server...";
+      const { port, promise: callbackPromise } = await startCallbackServer(state);
+      const authUrl = new URL(`${config.getApiUrl()}/auth/agent`);
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("machine_id", machineId);
+      authUrl.searchParams.set("machine_name", machineName);
+      authUrl.searchParams.set("redirect_uri", `http://localhost:${port}/auth/callback`);
+      spinner.text = "Opening browser for authentication...";
+      await open(authUrl.toString());
+      spinner.text = "Waiting for authentication...";
+      logger.info("login", `Login initiated, callback server listening on port ${port}`);
+      const token = await callbackPromise;
+      spinner.text = "Completing authentication...";
+      await completeLogin(token);
+      spinner.stop();
+    } catch (error) {
+      spinner.fail("Authentication failed");
+      logger.error("login", "Login failed", error);
+      console.error(chalk.red(`
+\u2716 Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+async function completeLogin(token) {
+  const spinner = ora("Saving authentication token...").start();
+  try {
+    await authService.saveToken(token);
+    spinner.text = "Validating token...";
+    const user = await authService.validateToken();
+    if (!user) {
+      throw new Error("Token validation failed");
+    }
+    spinner.succeed("Authentication successful!");
+    console.log(chalk.green(`
+\u2713 Logged in as ${chalk.bold(user.email)}`));
+    console.log(chalk.gray(`Machine: ${authService.getMachineName()} (${authService.getMachineId()})
+`));
+    logger.success("login", `Logged in as ${user.email}`);
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    throw error;
+  }
+}
+// src/commands/logout.ts
+import ora2 from "ora";
+import chalk2 from "chalk";
+function registerLogoutCommand(program2) {
+  program2.command("logout").description("Log out and remove stored credentials").action(async () => {
+    const spinner = ora2("Logging out...").start();
+    try {
+      const token = await authService.getToken();
+      if (!token) {
+        spinner.info("Not currently logged in");
+        return;
+      }
+      try {
+        await apiService.disconnect();
+      } catch {
+        logger.warn("logout", "Failed to disconnect session, continuing with logout");
+      }
+      await authService.clearToken();
+      spinner.succeed("Logged out successfully");
+      console.log(chalk2.gray("\nYour credentials have been removed from this machine.\n"));
+      logger.success("logout", "User logged out");
+    } catch (error) {
+      spinner.fail("Logout failed");
+      logger.error("logout", "Logout failed", error);
+      console.error(chalk2.red(`
+\u2716 Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+// src/commands/whoami.ts
+import ora3 from "ora";
+import chalk3 from "chalk";
+function registerWhoamiCommand(program2) {
+  program2.command("whoami").description("Show current user and machine information").action(async () => {
+    const spinner = ora3("Checking authentication...").start();
+    try {
+      const token = await authService.getToken();
+      if (!token) {
+        spinner.info("Not logged in");
+        console.log(chalk3.yellow("\n\u26A0 You are not logged in."));
+        console.log(chalk3.gray('Run "stint login" to authenticate.\n'));
+        return;
+      }
+      spinner.text = "Validating credentials...";
+      const user = await authService.validateToken();
+      if (!user) {
+        spinner.fail("Authentication invalid");
+        console.log(chalk3.red("\n\u2716 Your authentication token is invalid or expired."));
+        console.log(chalk3.gray('Run "stint login" to re-authenticate.\n'));
+        await authService.clearToken();
+        return;
+      }
+      spinner.succeed("Authenticated");
+      console.log(chalk3.blue("\n\u{1F464} User Information:"));
+      console.log(chalk3.gray("\u2500".repeat(50)));
+      console.log(`${chalk3.bold("Name:")}     ${user.name}`);
+      console.log(`${chalk3.bold("Email:")}    ${user.email}`);
+      console.log(`${chalk3.bold("User ID:")}  ${user.id}`);
+      console.log(chalk3.blue("\n\u{1F4BB} Machine Information:"));
+      console.log(chalk3.gray("\u2500".repeat(50)));
+      console.log(`${chalk3.bold("Name:")}     ${authService.getMachineName()}`);
+      console.log(`${chalk3.bold("ID:")}       ${authService.getMachineId()}`);
+      console.log();
+      logger.info("whoami", `User: ${user.email}, Machine: ${authService.getMachineName()}`);
+    } catch (error) {
+      spinner.fail("Failed to retrieve information");
+      logger.error("whoami", "Command failed", error);
+      console.error(chalk3.red(`
+\u2716 Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}
+// src/commands/link.ts
+import { select } from "@inquirer/prompts";
+import ora4 from "ora";
+import chalk4 from "chalk";
+import process2 from "process";
+function registerLinkCommand(program2) {
+  program2.command("link").description("Link current directory to a Stint project").action(async () => {
+    const spinner = ora4("Checking directory...").start();
+    try {
+      const cwd = process2.cwd();
+      const existingLink = projectService.getLinkedProject(cwd);
+      if (existingLink) {
+        spinner.warn("Directory already linked");
+        console.log(chalk4.yellow(`
+\u26A0 This directory is already linked to project ${existingLink.projectId}`));
+        console.log(chalk4.gray('Run "stint unlink" first if you want to link to a different project.\n'));
+        return;
+      }
+      spinner.text = "Verifying git repository...";
+      const isRepo = await gitService.isRepo(cwd);
+      if (!isRepo) {
+        spinner.fail("Not a git repository");
+        console.log(chalk4.red("\n\u2716 This directory is not a git repository."));
+        console.log(chalk4.gray("Please run this command in a git repository.\n"));
+        process2.exit(1);
+      }
+      spinner.text = "Fetching projects...";
+      const projects = await apiService.getLinkedProjects();
+      if (projects.length === 0) {
+        spinner.info("No projects available");
+        console.log(chalk4.yellow("\n\u26A0 No projects found in your Stint account."));
+        console.log(chalk4.gray("Create a project at https://stint.codes first.\n"));
+        return;
+      }
+      spinner.succeed("Ready to link");
+      const selectedProjectId = await select({
+        message: "Select a project to link:",
+        choices: projects.map((project) => ({
+          name: `${project.name}${project.description ? ` - ${project.description}` : ""}`,
+          value: project.id,
+          description: `ID: ${project.id}`
+        }))
+      });
+      const linkSpinner = ora4("Linking project...").start();
+      await projectService.linkProject(cwd, selectedProjectId);
+      const selectedProject = projects.find((p) => p.id === selectedProjectId);
+      linkSpinner.succeed("Project linked successfully!");
+      console.log(chalk4.green(`
+\u2713 Linked to ${chalk4.bold(selectedProject?.name || selectedProjectId)}`));
+      console.log(chalk4.gray(`Directory: ${cwd}`));
+      console.log(chalk4.gray(`Project ID: ${selectedProjectId}
+`));
+      logger.success("link", `Linked ${cwd} to project ${selectedProjectId}`);
+    } catch (error) {
+      spinner.fail("Failed to link project");
+      logger.error("link", "Link command failed", error);
+      console.error(chalk4.red(`
+\u2716 Error: ${error.message}
+`));
+      process2.exit(1);
+    }
+  });
+}
+// src/commands/unlink.ts
+import { confirm } from "@inquirer/prompts";
+import ora5 from "ora";
+import chalk5 from "chalk";
+import process3 from "process";
+function registerUnlinkCommand(program2) {
+  program2.command("unlink").description("Remove link from current directory").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+    const spinner = ora5("Checking directory...").start();
+    try {
+      const cwd = process3.cwd();
+      const linkedProject = projectService.getLinkedProject(cwd);
+      if (!linkedProject) {
+        spinner.info("Not linked");
+        console.log(chalk5.yellow("\n\u26A0 This directory is not linked to any project.\n"));
+        return;
+      }
+      spinner.stop();
+      console.log(chalk5.blue("\n\u{1F4CB} Current Link:"));
+      console.log(chalk5.gray("\u2500".repeat(50)));
+      console.log(`${chalk5.bold("Project ID:")}  ${linkedProject.projectId}`);
+      console.log(`${chalk5.bold("Linked At:")}   ${new Date(linkedProject.linkedAt).toLocaleString()}`);
+      console.log();
+      if (!options.force) {
+        const shouldUnlink = await confirm({
+          message: "Are you sure you want to unlink this directory?",
+          default: false
+        });
+        if (!shouldUnlink) {
+          console.log(chalk5.gray("Cancelled.\n"));
+          return;
+        }
+      }
+      const unlinkSpinner = ora5("Unlinking...").start();
+      await projectService.unlinkProject(cwd);
+      unlinkSpinner.succeed("Unlinked successfully");
+      console.log(chalk5.gray(`
+Directory ${cwd} is no longer linked.
+`));
+      logger.success("unlink", `Unlinked ${cwd}`);
+    } catch (error) {
+      spinner.fail("Failed to unlink");
+      logger.error("unlink", "Unlink command failed", error);
+      console.error(chalk5.red(`
+\u2716 Error: ${error.message}
+`));
+      process3.exit(1);
+    }
+  });
+}
+// src/commands/status.ts
+import ora6 from "ora";
+import chalk6 from "chalk";
+import process4 from "process";
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show linked project and connection status").action(async () => {
+    const spinner = ora6("Gathering status...").start();
+    try {
+      const cwd = process4.cwd();
+      const linkedProject = projectService.getLinkedProject(cwd);
+      const user = await authService.validateToken();
+      spinner.stop();
+      console.log(chalk6.blue("\n\u{1F4E6} Project Status:"));
+      console.log(chalk6.gray("\u2500".repeat(50)));
+      if (linkedProject) {
+        console.log(`${chalk6.bold("Status:")}      ${chalk6.green("\u2713 Linked")}`);
+        console.log(`${chalk6.bold("Project ID:")}  ${linkedProject.projectId}`);
+        console.log(`${chalk6.bold("Linked At:")}   ${new Date(linkedProject.linkedAt).toLocaleString()}`);
+      } else {
+        console.log(`${chalk6.bold("Status:")}      ${chalk6.yellow("Not linked")}`);
+        console.log(chalk6.gray('Run "stint link" to link this directory to a project.'));
+      }
+      console.log(chalk6.blue("\n\u{1F4C2} Git Repository:"));
+      console.log(chalk6.gray("\u2500".repeat(50)));
+      const isRepo = await gitService.isRepo(cwd);
+      if (isRepo) {
+        try {
+          const repoInfo = await gitService.getRepoInfo(cwd);
+          console.log(`${chalk6.bold("Branch:")}        ${chalk6.cyan(repoInfo.currentBranch)}`);
+          console.log(`${chalk6.bold("Remote:")}        ${repoInfo.remoteUrl || chalk6.gray("None")}`);
+          console.log(`${chalk6.bold("Last Commit:")}   ${repoInfo.lastCommitSha.substring(0, 7)} - ${repoInfo.lastCommitMessage}`);
+          console.log(`${chalk6.bold("Commit Date:")}   ${new Date(repoInfo.lastCommitDate).toLocaleString()}`);
+          const { staged, unstaged, untracked, ahead, behind } = repoInfo.status;
+          const totalChanges = staged.length + unstaged.length + untracked.length;
+          if (totalChanges > 0) {
+            console.log(`${chalk6.bold("Changes:")}      ${chalk6.yellow(`${totalChanges} file(s)`)}`);
+            if (staged.length > 0) console.log(`  ${chalk6.green("Staged:")}     ${staged.length}`);
+            if (unstaged.length > 0) console.log(`  ${chalk6.yellow("Unstaged:")}   ${unstaged.length}`);
+            if (untracked.length > 0) console.log(`  ${chalk6.gray("Untracked:")}  ${untracked.length}`);
+          } else {
+            console.log(`${chalk6.bold("Changes:")}      ${chalk6.green("Clean working tree")}`);
+          }
+          if (ahead > 0 || behind > 0) {
+            console.log(`${chalk6.bold("Sync Status:")}  ${ahead > 0 ? chalk6.yellow(`\u2191${ahead}`) : ""} ${behind > 0 ? chalk6.yellow(`\u2193${behind}`) : ""}`);
+          }
+        } catch {
+          console.log(chalk6.red("Error reading repository information"));
+        }
+      } else {
+        console.log(chalk6.yellow("Not a git repository"));
+      }
+      console.log(chalk6.blue("\n\u{1F510} Authentication:"));
+      console.log(chalk6.gray("\u2500".repeat(50)));
+      if (user) {
+        console.log(`${chalk6.bold("Status:")}      ${chalk6.green("\u2713 Authenticated")}`);
+        console.log(`${chalk6.bold("User:")}        ${user.name} (${user.email})`);
+        console.log(`${chalk6.bold("Machine:")}     ${authService.getMachineName()}`);
+      } else {
+        console.log(`${chalk6.bold("Status:")}      ${chalk6.yellow("Not logged in")}`);
+        console.log(chalk6.gray('Run "stint login" to authenticate.'));
+      }
+      console.log(chalk6.blue("\n\u2699\uFE0F  Daemon:"));
+      console.log(chalk6.gray("\u2500".repeat(50)));
+      console.log(`${chalk6.bold("Status:")}      ${chalk6.gray("Not running (Phase 3)")}`);
+      console.log();
+      logger.info("status", "Status command executed");
+    } catch (error) {
+      spinner.fail("Failed to get status");
+      logger.error("status", "Status command failed", error);
+      console.error(chalk6.red(`
+\u2716 Error: ${error.message}
+`));
+      process4.exit(1);
+    }
+  });
+}
+// src/commands/sync.ts
+import ora7 from "ora";
+import chalk7 from "chalk";
+import process5 from "process";
+function registerSyncCommand(program2) {
+  program2.command("sync").description("Manually sync repository information to server").action(async () => {
+    const spinner = ora7("Checking directory...").start();
+    try {
+      const cwd = process5.cwd();
+      const linkedProject = projectService.getLinkedProject(cwd);
+      if (!linkedProject) {
+        spinner.fail("Not linked");
+        console.log(chalk7.yellow("\n\u26A0 This directory is not linked to any project."));
+        console.log(chalk7.gray('Run "stint link" first to link this directory.\n'));
+        process5.exit(1);
+      }
+      spinner.text = "Gathering repository 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"));
+      console.log(chalk7.gray("\u2500".repeat(50)));
+      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}`);
+      console.log(`${chalk7.bold("Remote:")}      ${repoInfo.remoteUrl || chalk7.gray("None")}`);
+      console.log();
+      logger.success("sync", `Synced ${cwd} to project ${linkedProject.projectId}`);
+    } catch (error) {
+      spinner.fail("Sync failed");
+      logger.error("sync", "Sync command failed", error);
+      console.error(chalk7.red(`
+\u2716 Error: ${error.message}
+`));
+      process5.exit(1);
+    }
+  });
+}
+// src/commands/daemon.ts
+import ora8 from "ora";
+import chalk8 from "chalk";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+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 () => {
+    const spinner = ora8("Starting daemon...").start();
+    try {
+      const { valid, pid } = validatePidFile();
+      if (valid && pid) {
+        spinner.info("Daemon already running");
+        console.log(chalk8.yellow(`
+\u26A0 Daemon is already running (PID: ${pid})
+`));
+        return;
+      }
+      spinner.text = "Validating authentication...";
+      const user = await authService.validateToken();
+      if (!user) {
+        spinner.fail("Not authenticated");
+        console.log(chalk8.red("\n\u2716 You must be logged in to start the daemon."));
+        console.log(chalk8.gray('Run "stint login" first.\n'));
+        process.exit(1);
+      }
+      const runnerPath = path.join(__dirname, "daemon", "runner.js");
+      if (!fs.existsSync(runnerPath)) {
+        throw new Error(`Daemon runner not found at ${runnerPath}`);
+      }
+      spinner.text = "Spawning daemon process...";
+      const daemonPid = spawnDetached("node", [runnerPath]);
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (!isProcessRunning(daemonPid)) {
+        throw new Error("Daemon failed to start");
+      }
+      spinner.succeed("Daemon started successfully!");
+      console.log(chalk8.green(`
+\u2713 Daemon is running in the background`));
+      console.log(chalk8.gray(`PID: ${daemonPid}`));
+      console.log(chalk8.gray(`Logs: ${path.join(os.homedir(), ".config", "stint", "logs", "daemon.log")}
+`));
+      logger.success("daemon", `Daemon started with PID ${daemonPid}`);
+    } catch (error) {
+      spinner.fail("Failed to start daemon");
+      logger.error("daemon", "Start command failed", error);
+      console.error(chalk8.red(`
+\u2716 Error: ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+  daemon.command("stop").description("Stop the running daemon").action(async () => {
+    const spinner = ora8("Stopping daemon...").start();
+    try {
+      const { valid, pid } = validatePidFile();
+      if (!valid || !pid) {
+        spinner.info("Daemon not running");
+        console.log(chalk8.yellow("\n\u26A0 Daemon is not running.\n"));
+        return;
+      }
+      spinner.text = `Sending shutdown signal to process ${pid}...`;
+      killProcess(pid, "SIGTERM");
+      spinner.text = "Waiting for daemon to shutdown...";
+      let attempts = 0;
+      const maxAttempts = 10;
+      while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        if (!isProcessRunning(pid)) {
+          break;
+        }
+        attempts++;
+      }
+      if (isProcessRunning(pid)) {
+        spinner.warn("Daemon did not stop gracefully, forcing shutdown...");
+        killProcess(pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+      spinner.succeed("Daemon stopped successfully");
+      console.log(chalk8.gray("\nDaemon has been stopped.\n"));
+      logger.success("daemon", "Daemon stopped");
+    } catch (error) {
+      spinner.fail("Failed to stop daemon");
+      logger.error("daemon", "Stop command failed", error);
+      console.error(chalk8.red(`
+\u2716 Error: ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+  daemon.command("status").description("Check if the daemon is running").action(async () => {
+    const spinner = ora8("Checking daemon status...").start();
+    try {
+      const { valid, pid } = validatePidFile();
+      spinner.stop();
+      console.log(chalk8.blue("\n\u2699\uFE0F  Daemon Status:"));
+      console.log(chalk8.gray("\u2500".repeat(50)));
+      if (valid && pid) {
+        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:")}        ${path.join(os.homedir(), ".config", "stint", "logs", "daemon.log")}`);
+      } else {
+        console.log(`${chalk8.bold("Status:")}      ${chalk8.yellow("Not running")}`);
+        console.log(chalk8.gray('Run "stint daemon start" to start the daemon.'));
+      }
+      console.log();
+      logger.info("daemon", `Status check: ${valid ? "running" : "not running"}`);
+    } catch (error) {
+      spinner.fail("Failed to check status");
+      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 = path.join(os.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);
+    }
+  });
+  daemon.command("restart").description("Restart the daemon").action(async () => {
+    console.log(chalk8.blue("\u{1F504} Restarting daemon...\n"));
+    const { valid, pid } = validatePidFile();
+    if (valid && pid) {
+      const stopSpinner = ora8("Stopping daemon...").start();
+      try {
+        killProcess(pid, "SIGTERM");
+        let attempts = 0;
+        while (attempts < 10 && isProcessRunning(pid)) {
+          await new Promise((resolve) => setTimeout(resolve, 500));
+          attempts++;
+        }
+        if (isProcessRunning(pid)) {
+          killProcess(pid, "SIGKILL");
+        }
+        stopSpinner.succeed("Daemon stopped");
+      } catch (error) {
+        stopSpinner.fail("Failed to stop daemon");
+        throw error;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    const startSpinner = ora8("Starting daemon...").start();
+    try {
+      const user = await authService.validateToken();
+      if (!user) {
+        throw new Error("Not authenticated");
+      }
+      const runnerPath = path.join(__dirname, "daemon", "runner.js");
+      const daemonPid = spawnDetached("node", [runnerPath]);
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (!isProcessRunning(daemonPid)) {
+        throw new Error("Daemon failed to start");
+      }
+      startSpinner.succeed("Daemon started");
+      console.log(chalk8.green(`
+\u2713 Daemon restarted successfully (PID: ${daemonPid})
+`));
+      logger.success("daemon", `Daemon restarted with PID ${daemonPid}`);
+    } catch (error) {
+      startSpinner.fail("Failed to start daemon");
+      throw error;
+    }
+  });
+}
+// src/commands/commit.ts
+import ora9 from "ora";
+import chalk9 from "chalk";
+import process6 from "process";
+function registerCommitCommands(program2) {
+  program2.command("commits").description("List pending commits for the current project").action(async () => {
+    const spinner = ora9("Loading pending commits...").start();
+    try {
+      const cwd = process6.cwd();
+      const linkedProject = projectService.getLinkedProject(cwd);
+      if (!linkedProject) {
+        spinner.fail("Not linked");
+        console.log(chalk9.yellow("\n\u26A0 This directory is not linked to any project."));
+        console.log(chalk9.gray('Run "stint link" first to link this directory.\n'));
+        process6.exit(1);
+      }
+      spinner.text = "Fetching pending commits...";
+      const commits = await apiService.getPendingCommits(linkedProject.projectId);
+      spinner.stop();
+      if (commits.length === 0) {
+        console.log(chalk9.blue("\n\u{1F4CB} No pending commits\n"));
+        console.log(chalk9.gray("All commits have been executed.\n"));
+        return;
+      }
+      console.log(chalk9.blue(`
+\u{1F4CB} Pending Commits (${commits.length}):
+`));
+      commits.forEach((commit) => {
+        const shortId = commit.id.substring(0, 7);
+        const date = new Date(commit.createdAt);
+        const timeAgo = getTimeAgo(date);
+        console.log(`  ${chalk9.cyan(shortId)}  ${commit.message.padEnd(40)}  ${chalk9.gray(timeAgo)}`);
+        if (commit.files && commit.files.length > 0) {
+          console.log(chalk9.gray(`           Files: ${commit.files.join(", ")}`));
+        }
+      });
+      console.log(chalk9.gray('\nRun "stint commit <id>" to execute a specific commit.\n'));
+      logger.info("commits", `Listed ${commits.length} pending commits`);
+    } catch (error) {
+      spinner.fail("Failed to fetch commits");
+      logger.error("commits", "Failed to fetch commits", error);
+      console.error(chalk9.red(`
+\u2716 Error: ${error.message}
+`));
+      process6.exit(1);
+    }
+  });
+  program2.command("commit <id>").description("Execute a specific pending commit").action(async (id) => {
+    const spinner = ora9("Executing commit...").start();
+    try {
+      const cwd = process6.cwd();
+      const linkedProject = projectService.getLinkedProject(cwd);
+      if (!linkedProject) {
+        spinner.fail("Not linked");
+        console.log(chalk9.yellow("\n\u26A0 This directory is not linked to any project."));
+        console.log(chalk9.gray('Run "stint link" first to link this directory.\n'));
+        process6.exit(1);
+      }
+      spinner.text = "Fetching commit details...";
+      const commits = await apiService.getPendingCommits(linkedProject.projectId);
+      const commit = commits.find((c) => c.id.startsWith(id));
+      if (!commit) {
+        spinner.fail("Commit not found");
+        console.log(chalk9.red(`
+\u2716 Commit ${id} not found in pending commits.
+`));
+        console.log(chalk9.gray('Run "stint commits" to see available commits.\n'));
+        process6.exit(1);
+      }
+      spinner.text = `Executing commit: ${commit.message}`;
+      const project = {
+        id: linkedProject.projectId,
+        name: "Current Project",
+        // We don't have the name, but it's not critical
+        createdAt: "",
+        updatedAt: ""
+      };
+      const sha = await commitQueue.executeCommit(commit, project);
+      spinner.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();
+      logger.success("commit", `Executed commit ${commit.id} -> ${sha}`);
+    } catch (error) {
+      spinner.fail("Commit execution failed");
+      logger.error("commit", "Failed to execute commit", error);
+      console.error(chalk9.red(`
+\u2716 Error: ${error.message}
+`));
+      process6.exit(1);
+    }
+  });
+}
+function getTimeAgo(date) {
+  const now = /* @__PURE__ */ new Date();
+  const seconds = Math.floor((now.getTime() - date.getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)} minutes ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)} hours ago`;
+  if (seconds < 604800) return `${Math.floor(seconds / 86400)} days ago`;
+  return date.toLocaleDateString();
+}
+// src/index.ts
+var program = new Command();
+program.name("stint").description("Stint Agent - Local daemon for Stint Project Assistant").version("1.0.0").addHelpText("after", `
+${chalk10.bold("Examples:")}
+  ${chalk10.cyan("$")} stint login                 ${chalk10.gray("# Authenticate with Stint")}
+  ${chalk10.cyan("$")} stint link                  ${chalk10.gray("# Link current directory to a project")}
+  ${chalk10.cyan("$")} stint daemon start          ${chalk10.gray("# Start background daemon")}
+  ${chalk10.cyan("$")} stint status                ${chalk10.gray("# Check status")}
+  ${chalk10.cyan("$")} stint commits               ${chalk10.gray("# List pending commits")}
+${chalk10.bold("Documentation:")}
+  For more information, visit: ${chalk10.blue("https://stint.codes/docs")}
+    `);
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerWhoamiCommand(program);
+registerLinkCommand(program);
+registerUnlinkCommand(program);
+registerStatusCommand(program);
+registerSyncCommand(program);
+registerDaemonCommands(program);
+registerCommitCommands(program);
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  const commanderError = error;
+  if (commanderError.code !== "commander.help" && commanderError.code !== "commander.version") {
+    logger.error("cli", "Command execution failed", error);
+    console.error(chalk10.red(`
+\u2716 Error: ${error.message}
+`));
+    process.exit(1);
+  }
+}