@stackmemoryai/stackmemory 0.5.0 → 0.5.2

package/dist/cli/commands/service.js

@@ -0,0 +1,684 @@
+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";
+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 Error("Failed to load launchd service");
+      }
+    }
+    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 Error(
+        "Failed to enable systemd service. Make sure systemd user session is available."
+      );
+    }
+    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}`));
+  }
+}
+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
+};
+//# sourceMappingURL=service.js.map