@stackmemoryai/stackmemory 0.5.59 → 0.5.61

package/dist/cli/commands/service.js

@@ -1,749 +0,0 @@
-import { fileURLToPath as __fileURLToPath } from 'url';
-import { dirname as __pathDirname } from 'path';
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __pathDirname(__filename);
-import { Command } from "commander";
-import chalk from "chalk";
-import ora from "ora";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { spawn, execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { SystemError, ErrorCode } from "../../core/errors/index.js";
-function getServiceConfig() {
-  const home = process.env.HOME || "";
-  const platform = process.platform;
-  if (platform === "darwin") {
-    return {
-      platform: "darwin",
-      serviceDir: path.join(home, "Library", "LaunchAgents"),
-      serviceName: "com.stackmemory.guardian",
-      serviceFile: path.join(
-        home,
-        "Library",
-        "LaunchAgents",
-        "com.stackmemory.guardian.plist"
-      ),
-      logDir: path.join(home, ".stackmemory", "logs")
-    };
-  } else if (platform === "linux") {
-    return {
-      platform: "linux",
-      serviceDir: path.join(home, ".config", "systemd", "user"),
-      serviceName: "stackmemory-guardian",
-      serviceFile: path.join(
-        home,
-        ".config",
-        "systemd",
-        "user",
-        "stackmemory-guardian.service"
-      ),
-      logDir: path.join(home, ".stackmemory", "logs")
-    };
-  }
-  return {
-    platform: "unsupported",
-    serviceDir: "",
-    serviceName: "",
-    serviceFile: "",
-    logDir: path.join(home, ".stackmemory", "logs")
-  };
-}
-function _getStackMemoryBinPath() {
-  const localBin = path.join(process.cwd(), "dist", "cli", "index.js");
-  if (existsSync(localBin)) {
-    return localBin;
-  }
-  const globalBin = path.join(
-    process.env.HOME || "",
-    ".stackmemory",
-    "bin",
-    "stackmemory"
-  );
-  if (existsSync(globalBin)) {
-    return globalBin;
-  }
-  return "npx stackmemory";
-}
-void _getStackMemoryBinPath;
-function getNodePath() {
-  try {
-    const nodePath = execSync("which node", { encoding: "utf-8" }).trim();
-    return nodePath;
-  } catch {
-    return "/usr/local/bin/node";
-  }
-}
-function generateMacOSPlist(config) {
-  const home = process.env.HOME || "";
-  const nodePath = getNodePath();
-  const guardianScript = path.join(home, ".stackmemory", "guardian.js");
-  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>${config.serviceName}</string>
-
-    <key>ProgramArguments</key>
-    <array>
-        <string>${nodePath}</string>
-        <string>${guardianScript}</string>
-    </array>
-
-    <key>RunAtLoad</key>
-    <true/>
-
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-
-    <key>WorkingDirectory</key>
-    <string>${home}/.stackmemory</string>
-
-    <key>StandardOutPath</key>
-    <string>${config.logDir}/guardian.log</string>
-
-    <key>StandardErrorPath</key>
-    <string>${config.logDir}/guardian.error.log</string>
-
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>HOME</key>
-        <string>${home}</string>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin</string>
-    </dict>
-
-    <key>ThrottleInterval</key>
-    <integer>30</integer>
-</dict>
-</plist>`;
-}
-function generateLinuxSystemdService(config) {
-  const home = process.env.HOME || "";
-  const nodePath = getNodePath();
-  const guardianScript = path.join(home, ".stackmemory", "guardian.js");
-  return `[Unit]
-Description=StackMemory Guardian Service
-Documentation=https://github.com/stackmemoryai/stackmemory
-After=network.target
-
-[Service]
-Type=simple
-ExecStart=${nodePath} ${guardianScript}
-Restart=on-failure
-RestartSec=30
-WorkingDirectory=${home}/.stackmemory
-
-Environment=HOME=${home}
-Environment=PATH=/usr/local/bin:/usr/bin:/bin
-
-StandardOutput=append:${config.logDir}/guardian.log
-StandardError=append:${config.logDir}/guardian.error.log
-
-[Install]
-WantedBy=default.target`;
-}
-function generateGuardianScript() {
-  return `#!/usr/bin/env node
-/**
- * StackMemory Guardian Service
- * Monitors ~/.stackmemory/sessions/ for active sessions
- * and manages context sync accordingly.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const HOME = process.env.HOME || '';
-const SESSIONS_DIR = path.join(HOME, '.stackmemory', 'sessions');
-const STATE_FILE = path.join(HOME, '.stackmemory', 'guardian.state');
-const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-
-class Guardian {
-  constructor() {
-    this.syncProcess = null;
-    this.lastActivityTime = Date.now();
-    this.activeSessions = new Set();
-    this.checkInterval = null;
-  }
-
-  log(message, level = 'INFO') {
-    const timestamp = new Date().toISOString();
-    console.log('[' + timestamp + '] [' + level + '] ' + message);
-  }
-
-  async getActiveSessions() {
-    const sessions = new Set();
-
-    try {
-      if (!fs.existsSync(SESSIONS_DIR)) {
-        return sessions;
-      }
-
-      const files = fs.readdirSync(SESSIONS_DIR);
-
-      for (const file of files) {
-        if (!file.endsWith('.json')) continue;
-
-        const filePath = path.join(SESSIONS_DIR, file);
-        try {
-          const content = fs.readFileSync(filePath, 'utf8');
-          const session = JSON.parse(content);
-
-          // Check if session is active (updated within last 5 minutes)
-          const lastUpdate = new Date(session.lastActiveAt || session.startedAt).getTime();
-          const fiveMinutesAgo = Date.now() - (5 * 60 * 1000);
-
-          if (session.state === 'active' && lastUpdate > fiveMinutesAgo) {
-            sessions.add(session.sessionId);
-          }
-        } catch (err) {
-          // Skip invalid session files
-        }
-      }
-    } catch (err) {
-      this.log('Error reading sessions: ' + err.message, 'ERROR');
-    }
-
-    return sessions;
-  }
-
-  startContextSync() {
-    if (this.syncProcess) {
-      this.log('Context sync already running');
-      return;
-    }
-
-    this.log('Starting context sync...');
-
-    // Find stackmemory binary
-    const stackmemoryPaths = [
-      path.join(HOME, '.stackmemory', 'bin', 'stackmemory'),
-      'npx'
-    ];
-
-    let binPath = null;
-    for (const p of stackmemoryPaths) {
-      if (p === 'npx' || fs.existsSync(p)) {
-        binPath = p;
-        break;
-      }
-    }
-
-    if (!binPath) {
-      this.log('Cannot find stackmemory binary', 'ERROR');
-      return;
-    }
-
-    const args = binPath === 'npx'
-      ? ['stackmemory', 'monitor', '--daemon']
-      : ['monitor', '--daemon'];
-
-    this.syncProcess = spawn(binPath, args, {
-      detached: true,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    this.syncProcess.stdout.on('data', (data) => {
-      this.log('sync: ' + data.toString().trim());
-    });
-
-    this.syncProcess.stderr.on('data', (data) => {
-      this.log('sync error: ' + data.toString().trim(), 'WARN');
-    });
-
-    this.syncProcess.on('exit', (code) => {
-      this.log('Context sync exited with code: ' + code);
-      this.syncProcess = null;
-    });
-
-    this.log('Context sync started');
-  }
-
-  stopContextSync() {
-    if (!this.syncProcess) {
-      return;
-    }
-
-    this.log('Stopping context sync...');
-
-    try {
-      this.syncProcess.kill('SIGTERM');
-      this.syncProcess = null;
-      this.log('Context sync stopped');
-    } catch (err) {
-      this.log('Error stopping sync: ' + err.message, 'ERROR');
-    }
-  }
-
-  saveState() {
-    const state = {
-      lastCheck: new Date().toISOString(),
-      activeSessions: Array.from(this.activeSessions),
-      syncRunning: this.syncProcess !== null,
-      lastActivity: new Date(this.lastActivityTime).toISOString()
-    };
-
-    try {
-      fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
-    } catch (err) {
-      this.log('Error saving state: ' + err.message, 'ERROR');
-    }
-  }
-
-  async check() {
-    const currentSessions = await this.getActiveSessions();
-    const hadActivity = currentSessions.size > 0;
-
-    if (hadActivity) {
-      this.lastActivityTime = Date.now();
-    }
-
-    // Detect session changes
-    const newSessions = [...currentSessions].filter(s => !this.activeSessions.has(s));
-    const closedSessions = [...this.activeSessions].filter(s => !currentSessions.has(s));
-
-    if (newSessions.length > 0) {
-      this.log('New sessions detected: ' + newSessions.join(', '));
-      if (!this.syncProcess) {
-        this.startContextSync();
-      }
-    }
-
-    if (closedSessions.length > 0) {
-      this.log('Sessions closed: ' + closedSessions.join(', '));
-    }
-
-    this.activeSessions = currentSessions;
-
-    // Check idle timeout
-    const idleTime = Date.now() - this.lastActivityTime;
-    if (this.syncProcess && currentSessions.size === 0 && idleTime > IDLE_TIMEOUT_MS) {
-      this.log('No activity for 30 minutes, stopping sync');
-      this.stopContextSync();
-    }
-
-    this.saveState();
-  }
-
-  async start() {
-    this.log('StackMemory Guardian starting...');
-    this.log('Monitoring: ' + SESSIONS_DIR);
-
-    // Ensure directories exist
-    const dirs = [
-      SESSIONS_DIR,
-      path.join(HOME, '.stackmemory', 'logs')
-    ];
-
-    for (const dir of dirs) {
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-    }
-
-    // Initial check
-    await this.check();
-
-    // Start monitoring loop (every 30 seconds)
-    this.checkInterval = setInterval(() => this.check(), 30 * 1000);
-
-    this.log('Guardian started successfully');
-
-    // Handle shutdown signals
-    process.on('SIGTERM', () => this.stop());
-    process.on('SIGINT', () => this.stop());
-  }
-
-  stop() {
-    this.log('Guardian stopping...');
-
-    if (this.checkInterval) {
-      clearInterval(this.checkInterval);
-    }
-
-    this.stopContextSync();
-
-    // Clean up state file
-    try {
-      if (fs.existsSync(STATE_FILE)) {
-        fs.unlinkSync(STATE_FILE);
-      }
-    } catch (err) {
-      // Ignore
-    }
-
-    this.log('Guardian stopped');
-    process.exit(0);
-  }
-}
-
-const guardian = new Guardian();
-guardian.start().catch(err => {
-  console.error('Guardian failed to start:', err);
-  process.exit(1);
-});
-`;
-}
-async function installService(config, spinner) {
-  const home = process.env.HOME || "";
-  await fs.mkdir(config.serviceDir, { recursive: true });
-  await fs.mkdir(config.logDir, { recursive: true });
-  const guardianPath = path.join(home, ".stackmemory", "guardian.js");
-  await fs.writeFile(guardianPath, generateGuardianScript(), "utf-8");
-  await fs.chmod(guardianPath, 493);
-  if (config.platform === "darwin") {
-    const plistContent = generateMacOSPlist(config);
-    await fs.writeFile(config.serviceFile, plistContent, "utf-8");
-    spinner.text = "Loading service...";
-    try {
-      execSync(`launchctl load -w "${config.serviceFile}"`, { stdio: "pipe" });
-    } catch {
-      try {
-        execSync(`launchctl unload "${config.serviceFile}"`, { stdio: "pipe" });
-        execSync(`launchctl load -w "${config.serviceFile}"`, {
-          stdio: "pipe"
-        });
-      } catch {
-        throw new SystemError(
-          "Failed to load launchd service",
-          ErrorCode.SERVICE_UNAVAILABLE,
-          { platform: "darwin", serviceFile: config.serviceFile }
-        );
-      }
-    }
-    spinner.succeed(chalk.green("Guardian service installed and started"));
-    console.log(chalk.gray(`Service file: ${config.serviceFile}`));
-    console.log(chalk.gray(`Guardian script: ${guardianPath}`));
-    console.log(chalk.gray(`Logs: ${config.logDir}/guardian.log`));
-  } else if (config.platform === "linux") {
-    const serviceContent = generateLinuxSystemdService(config);
-    await fs.writeFile(config.serviceFile, serviceContent, "utf-8");
-    spinner.text = "Enabling service...";
-    try {
-      execSync("systemctl --user daemon-reload", { stdio: "pipe" });
-      execSync(`systemctl --user enable ${config.serviceName}`, {
-        stdio: "pipe"
-      });
-      execSync(`systemctl --user start ${config.serviceName}`, {
-        stdio: "pipe"
-      });
-    } catch {
-      throw new SystemError(
-        "Failed to enable systemd service. Make sure systemd user session is available.",
-        ErrorCode.SERVICE_UNAVAILABLE,
-        { platform: "linux", serviceName: config.serviceName }
-      );
-    }
-    spinner.succeed(chalk.green("Guardian service installed and started"));
-    console.log(chalk.gray(`Service file: ${config.serviceFile}`));
-    console.log(chalk.gray(`Guardian script: ${guardianPath}`));
-    console.log(chalk.gray(`Logs: ${config.logDir}/guardian.log`));
-  }
-}
-async function uninstallService(config, spinner) {
-  const home = process.env.HOME || "";
-  const guardianPath = path.join(home, ".stackmemory", "guardian.js");
-  if (config.platform === "darwin") {
-    spinner.text = "Unloading service...";
-    try {
-      execSync(`launchctl unload "${config.serviceFile}"`, { stdio: "pipe" });
-    } catch {
-    }
-    try {
-      await fs.unlink(config.serviceFile);
-    } catch {
-    }
-    try {
-      await fs.unlink(guardianPath);
-    } catch {
-    }
-    spinner.succeed(chalk.green("Guardian service uninstalled"));
-  } else if (config.platform === "linux") {
-    spinner.text = "Stopping service...";
-    try {
-      execSync(`systemctl --user stop ${config.serviceName}`, {
-        stdio: "pipe"
-      });
-      execSync(`systemctl --user disable ${config.serviceName}`, {
-        stdio: "pipe"
-      });
-    } catch {
-    }
-    try {
-      await fs.unlink(config.serviceFile);
-    } catch {
-    }
-    try {
-      await fs.unlink(guardianPath);
-    } catch {
-    }
-    try {
-      execSync("systemctl --user daemon-reload", { stdio: "pipe" });
-    } catch {
-    }
-    spinner.succeed(chalk.green("Guardian service uninstalled"));
-  }
-}
-async function showServiceStatus(config) {
-  const home = process.env.HOME || "";
-  const stateFile = path.join(home, ".stackmemory", "guardian.state");
-  console.log(chalk.bold("\nStackMemory Guardian Service Status\n"));
-  if (config.platform === "unsupported") {
-    console.log(chalk.red("Platform not supported for service installation"));
-    console.log(
-      chalk.gray("Supported platforms: macOS (launchd), Linux (systemd)")
-    );
-    return;
-  }
-  if (!existsSync(config.serviceFile)) {
-    console.log(chalk.yellow("Service not installed"));
-    console.log(chalk.gray("Install with: stackmemory service install"));
-    return;
-  }
-  let isRunning = false;
-  let serviceOutput = "";
-  if (config.platform === "darwin") {
-    try {
-      serviceOutput = execSync(`launchctl list | grep ${config.serviceName}`, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      isRunning = serviceOutput.includes(config.serviceName);
-    } catch {
-      isRunning = false;
-    }
-  } else if (config.platform === "linux") {
-    try {
-      serviceOutput = execSync(
-        `systemctl --user is-active ${config.serviceName}`,
-        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-      ).trim();
-      isRunning = serviceOutput === "active";
-    } catch {
-      isRunning = false;
-    }
-  }
-  if (isRunning) {
-    console.log(chalk.green("Status: Running"));
-  } else {
-    console.log(chalk.yellow("Status: Stopped"));
-  }
-  console.log(chalk.gray(`Platform: ${config.platform}`));
-  console.log(chalk.gray(`Service: ${config.serviceName}`));
-  console.log(chalk.gray(`Config: ${config.serviceFile}`));
-  if (existsSync(stateFile)) {
-    try {
-      const state = JSON.parse(readFileSync(stateFile, "utf-8"));
-      console.log(chalk.bold("\nGuardian State:"));
-      console.log(`  Last check: ${state.lastCheck}`);
-      console.log(`  Active sessions: ${state.activeSessions?.length || 0}`);
-      console.log(`  Sync running: ${state.syncRunning ? "Yes" : "No"}`);
-      console.log(`  Last activity: ${state.lastActivity}`);
-    } catch {
-    }
-  }
-}
-async function showServiceLogs(config, lines) {
-  console.log(
-    chalk.bold(`
-StackMemory Guardian Logs (last ${lines} lines)
-`)
-  );
-  const logFile = path.join(config.logDir, "guardian.log");
-  if (!existsSync(logFile)) {
-    console.log(chalk.yellow("No logs found"));
-    console.log(chalk.gray(`Expected at: ${logFile}`));
-    return;
-  }
-  try {
-    const content = readFileSync(logFile, "utf-8");
-    const logLines = content.split("\n").filter(Boolean);
-    const lastLines = logLines.slice(-lines);
-    lastLines.forEach((line) => {
-      if (line.includes("[ERROR]")) {
-        console.log(chalk.red(line));
-      } else if (line.includes("[WARN]")) {
-        console.log(chalk.yellow(line));
-      } else {
-        console.log(chalk.gray(line));
-      }
-    });
-    console.log(chalk.gray(`
-Full log: ${logFile}`));
-  } catch (err) {
-    console.log(chalk.red(`Failed to read logs: ${err.message}`));
-  }
-}
-async function installServiceSilent() {
-  try {
-    const config = getServiceConfig();
-    if (config.platform === "unsupported") {
-      return false;
-    }
-    const home = process.env.HOME || "";
-    await fs.mkdir(config.serviceDir, { recursive: true });
-    await fs.mkdir(config.logDir, { recursive: true });
-    const guardianPath = path.join(home, ".stackmemory", "guardian.js");
-    await fs.writeFile(guardianPath, generateGuardianScript(), "utf-8");
-    await fs.chmod(guardianPath, 493);
-    if (config.platform === "darwin") {
-      const plistContent = generateMacOSPlist(config);
-      await fs.writeFile(config.serviceFile, plistContent, "utf-8");
-      try {
-        execSync(`launchctl load -w "${config.serviceFile}"`, {
-          stdio: "pipe"
-        });
-      } catch {
-        try {
-          execSync(`launchctl unload "${config.serviceFile}"`, {
-            stdio: "pipe"
-          });
-          execSync(`launchctl load -w "${config.serviceFile}"`, {
-            stdio: "pipe"
-          });
-        } catch {
-          return false;
-        }
-      }
-      return true;
-    } else if (config.platform === "linux") {
-      const serviceContent = generateLinuxSystemdService(config);
-      await fs.writeFile(config.serviceFile, serviceContent, "utf-8");
-      try {
-        execSync("systemctl --user daemon-reload", { stdio: "pipe" });
-        execSync(`systemctl --user enable ${config.serviceName}`, {
-          stdio: "pipe"
-        });
-        execSync(`systemctl --user start ${config.serviceName}`, {
-          stdio: "pipe"
-        });
-      } catch {
-        return false;
-      }
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function createServiceCommand() {
-  const cmd = new Command("service").description("Manage StackMemory guardian OS service (auto-start on login)").addHelpText(
-    "after",
-    `
-Examples:
-  stackmemory service install     Install and start the guardian service
-  stackmemory service uninstall   Remove the guardian service
-  stackmemory service status      Show service status
-  stackmemory service logs        Show recent service logs
-  stackmemory service logs -n 50  Show last 50 log lines
-
-The guardian service:
-  - Monitors ~/.stackmemory/sessions/ for active sessions
-  - Starts context sync when an active session is detected
-  - Stops gracefully after 30 minutes of inactivity
-  - Runs automatically on system login (opt-in)
-`
-  );
-  cmd.command("install").description("Install the guardian service (starts on login)").action(async () => {
-    const spinner = ora("Installing guardian service...").start();
-    try {
-      const config = getServiceConfig();
-      if (config.platform === "unsupported") {
-        spinner.fail(chalk.red("Platform not supported"));
-        console.log(
-          chalk.gray("Supported: macOS (launchd), Linux (systemd)")
-        );
-        process.exit(1);
-      }
-      await installService(config, spinner);
-      console.log(chalk.bold("\nGuardian service will:"));
-      console.log("  - Start automatically on login");
-      console.log("  - Monitor for active StackMemory sessions");
-      console.log("  - Manage context sync based on activity");
-      console.log("  - Stop gracefully after 30 min idle");
-    } catch (err) {
-      spinner.fail(
-        chalk.red(`Installation failed: ${err.message}`)
-      );
-      process.exit(1);
-    }
-  });
-  cmd.command("uninstall").description("Remove the guardian service").action(async () => {
-    const spinner = ora("Uninstalling guardian service...").start();
-    try {
-      const config = getServiceConfig();
-      if (config.platform === "unsupported") {
-        spinner.fail(chalk.red("Platform not supported"));
-        process.exit(1);
-      }
-      await uninstallService(config, spinner);
-    } catch (err) {
-      spinner.fail(
-        chalk.red(`Uninstallation failed: ${err.message}`)
-      );
-      process.exit(1);
-    }
-  });
-  cmd.command("status").description("Show guardian service status").action(async () => {
-    try {
-      const config = getServiceConfig();
-      await showServiceStatus(config);
-    } catch (err) {
-      console.error(
-        chalk.red(`Status check failed: ${err.message}`)
-      );
-      process.exit(1);
-    }
-  });
-  cmd.command("logs").description("Show recent guardian service logs").option("-n, --lines <number>", "Number of log lines to show", "20").option("-f, --follow", "Follow log output (tail -f style)").action(async (options) => {
-    try {
-      const config = getServiceConfig();
-      const lines = parseInt(options.lines) || 20;
-      if (options.follow) {
-        const logFile = path.join(config.logDir, "guardian.log");
-        console.log(chalk.bold(`Following ${logFile} (Ctrl+C to stop)
-`));
-        const tail = spawn("tail", ["-f", "-n", lines.toString(), logFile], {
-          stdio: "inherit"
-        });
-        process.on("SIGINT", () => {
-          tail.kill();
-          process.exit(0);
-        });
-      } else {
-        await showServiceLogs(config, lines);
-      }
-    } catch (err) {
-      console.error(
-        chalk.red(`Failed to show logs: ${err.message}`)
-      );
-      process.exit(1);
-    }
-  });
-  cmd.action(async () => {
-    try {
-      const config = getServiceConfig();
-      await showServiceStatus(config);
-    } catch (err) {
-      console.error(
-        chalk.red(`Status check failed: ${err.message}`)
-      );
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-var service_default = createServiceCommand();
-export {
-  createServiceCommand,
-  service_default as default,
-  installServiceSilent
-};
-//# sourceMappingURL=service.js.map