botholomew 0.7.13 → 0.8.1

package/src/commands/daemon.ts

@@ -1,152 +0,0 @@
-import type { Command } from "commander";
-import { logger } from "../utils/logger.ts";
-
-export function registerDaemonCommand(program: Command) {
-  const daemon = program
-    .command("daemon")
-    .description("Manage the Botholomew daemon");
-
-  daemon
-    .command("run")
-    .description("Run the daemon in the foreground (blocks until stopped)")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { startDaemon } = await import("../daemon/index.ts");
-      await startDaemon(dir, { foreground: true });
-    });
-
-  daemon
-    .command("start")
-    .description("Start the daemon as a background process")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { spawnDaemon } = await import("../daemon/spawn.ts");
-      await spawnDaemon(dir);
-    });
-
-  daemon
-    .command("stop")
-    .description("Stop the daemon for this project")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { stopDaemon } = await import("../utils/pid.ts");
-      const stopped = await stopDaemon(dir);
-      if (stopped) {
-        logger.success("Daemon stopped.");
-      } else {
-        logger.warn("No running daemon found.");
-      }
-    });
-
-  daemon
-    .command("status")
-    .description("Check if the daemon is running")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { getDaemonStatus } = await import("../utils/pid.ts");
-      const status = await getDaemonStatus(dir);
-      if (status) {
-        logger.success(`Daemon running (PID ${status.pid})`);
-      } else {
-        logger.dim("Daemon is not running.");
-      }
-
-      const { getWatchdogStatus } = await import("../daemon/watchdog.ts");
-      try {
-        const watchdog = await getWatchdogStatus(dir);
-        if (watchdog.installed) {
-          logger.info(`Watchdog: installed (${watchdog.platform})`);
-          if (watchdog.configPath) {
-            logger.dim(`  Config: ${watchdog.configPath}`);
-          }
-        } else {
-          logger.dim("Watchdog: not installed");
-        }
-      } catch {
-        logger.dim("Watchdog: not installed");
-      }
-    });
-
-  daemon
-    .command("install")
-    .description("Install OS-level watchdog (launchd/systemd)")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { installWatchdog } = await import("../daemon/watchdog.ts");
-      try {
-        const result = await installWatchdog(dir);
-        logger.success(`Watchdog installed (${result.platform})`);
-        for (const p of result.paths) {
-          logger.dim(`  ${p}`);
-        }
-      } catch (err) {
-        logger.error(
-          `Failed to install watchdog: ${err instanceof Error ? err.message : err}`,
-        );
-      }
-    });
-
-  daemon
-    .command("uninstall")
-    .description("Remove OS-level watchdog")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { uninstallWatchdog } = await import("../daemon/watchdog.ts");
-      try {
-        const result = await uninstallWatchdog(dir);
-        if (result.removed) {
-          logger.success(`Watchdog removed (${result.platform})`);
-        } else {
-          logger.warn("No watchdog found to remove.");
-        }
-      } catch (err) {
-        logger.error(
-          `Failed to remove watchdog: ${err instanceof Error ? err.message : err}`,
-        );
-      }
-    });
-
-  daemon
-    .command("list")
-    .description("List all registered Botholomew projects on this machine")
-    .option("-l, --limit <n>", "max number of projects", Number.parseInt)
-    .option("-o, --offset <n>", "skip first N projects", Number.parseInt)
-    .action(async (opts: { limit?: number; offset?: number }) => {
-      const { listAllWatchdogProjects } = await import("../daemon/watchdog.ts");
-      try {
-        const projects = await listAllWatchdogProjects();
-        if (projects.length === 0) {
-          logger.dim("No registered projects found.");
-          return;
-        }
-        const total = projects.length;
-        const start = opts.offset ?? 0;
-        const end = opts.limit ? start + opts.limit : undefined;
-        const page = projects.slice(start, end);
-        if (page.length === 0) {
-          logger.dim(`No projects on this page (total: ${total}).`);
-          return;
-        }
-        for (const p of page) {
-          logger.info(p.projectDir);
-          logger.dim(`  Config: ${p.configPath}`);
-        }
-        if (page.length !== total) {
-          logger.dim(`\nshowing ${page.length} of ${total} project(s)`);
-        }
-      } catch (err) {
-        logger.error(
-          `Failed to list projects: ${err instanceof Error ? err.message : err}`,
-        );
-      }
-    });
-
-  daemon
-    .command("healthcheck")
-    .description("Run health check (used by watchdog)")
-    .action(async () => {
-      const dir = program.opts().dir;
-      const { runHealthCheck } = await import("../daemon/healthcheck.ts");
-      await runHealthCheck(dir);
-    });
-}

package/src/daemon/ensure-running.ts

@@ -1,16 +0,0 @@
-import { getDaemonStatus } from "../utils/pid.ts";
-import { spawnDaemon } from "./spawn.ts";
-
-/**
- * If no daemon is running for this project, spawn one in the background.
- * Returns true if a new daemon was spawned, false if one was already running.
- */
-export async function ensureDaemonRunning(
-  projectDir: string,
-): Promise<boolean> {
-  const status = await getDaemonStatus(projectDir);
-  if (status) return false;
-
-  await spawnDaemon(projectDir);
-  return true;
-}

package/src/daemon/healthcheck.ts

@@ -1,47 +0,0 @@
-import { rename } from "node:fs/promises";
-import { getLogPath, LOG_MAX_BYTES } from "../constants.ts";
-import { isProcessAlive, readPidFile, removePidFile } from "../utils/pid.ts";
-import { spawnDaemon } from "./spawn.ts";
-
-export async function runHealthCheck(projectDir: string): Promise<void> {
-  const pid = await readPidFile(projectDir);
-
-  if (pid !== null) {
-    if (isProcessAlive(pid)) {
-      // Daemon is healthy — nothing to do
-      return;
-    }
-    // Stale PID file — clean it up
-    await removePidFile(projectDir);
-  }
-
-  // Daemon is not running — start it
-  await spawnDaemon(projectDir);
-
-  // Rotate daemon.log if it's too large
-  await rotateLogIfNeeded(projectDir);
-}
-
-export async function rotateLogIfNeeded(projectDir: string): Promise<void> {
-  const logPath = getLogPath(projectDir);
-  const logFile = Bun.file(logPath);
-
-  if (!(await logFile.exists())) return;
-
-  if (logFile.size > LOG_MAX_BYTES) {
-    try {
-      await rename(logPath, `${logPath}.1`);
-    } catch {
-      // Best-effort rotation — don't fail the healthcheck
-    }
-  }
-}
-
-if (import.meta.main) {
-  const projectDir = process.argv[2];
-  if (!projectDir) {
-    console.error("Usage: bun run healthcheck.ts <projectDir>");
-    process.exit(1);
-  }
-  await runHealthCheck(projectDir);
-}

package/src/daemon/index.ts

@@ -1,106 +0,0 @@
-import ansis from "ansis";
-import { loadConfig } from "../config/loader.ts";
-import { getDbPath } from "../constants.ts";
-import { withDb } from "../db/connection.ts";
-import { migrate } from "../db/schema.ts";
-import { createMcpxClient } from "../mcpx/client.ts";
-import { logger } from "../utils/logger.ts";
-import { removePidFile, writePidFile } from "../utils/pid.ts";
-import type { DaemonStreamCallbacks } from "./llm.ts";
-import { tick } from "./tick.ts";
-
-function buildForegroundCallbacks(): DaemonStreamCallbacks {
-  return {
-    onTaskStart(task) {
-      process.stdout.write(
-        `\n${ansis.bold.blue(`Task: ${task.name}`)} ${ansis.dim(`(${task.id})`)}\n`,
-      );
-      if (task.description) {
-        process.stdout.write(`${ansis.dim(task.description)}\n`);
-      }
-      process.stdout.write("\n");
-    },
-    onToken(text) {
-      process.stdout.write(text);
-    },
-    onToolStart(name, input) {
-      process.stdout.write(
-        `  ${ansis.yellow("▶")} ${ansis.bold(name)} ${ansis.dim(input)}\n`,
-      );
-    },
-    onToolEnd(name, _output, isError, durationMs) {
-      const seconds = (durationMs / 1000).toFixed(1);
-      if (isError) {
-        process.stdout.write(
-          `  ${ansis.red("✗")} ${ansis.bold(name)} ${ansis.red("error")} ${ansis.dim(`(${seconds}s)`)}\n`,
-        );
-      } else {
-        process.stdout.write(
-          `  ${ansis.green("✓")} ${ansis.bold(name)} ${ansis.dim(`(${seconds}s)`)}\n`,
-        );
-      }
-    },
-  };
-}
-
-export async function startDaemon(
-  projectDir: string,
-  options?: { foreground?: boolean },
-): Promise<void> {
-  const config = await loadConfig(projectDir);
-  const dbPath = getDbPath(projectDir);
-
-  // One short-lived connection to apply migrations. After this returns,
-  // the file lock is released so CLI invocations can run freely.
-  await withDb(dbPath, (conn) => migrate(conn));
-
-  // Initialize MCPX client for external tool access
-  const mcpxClient = await createMcpxClient(projectDir);
-  if (mcpxClient) {
-    logger.info("MCPX client initialized with external tools");
-  }
-
-  writePidFile(projectDir, process.pid);
-
-  const shutdown = async () => {
-    logger.info("Daemon shutting down...");
-    await mcpxClient?.close();
-    await removePidFile(projectDir);
-    process.exit(0);
-  };
-
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-
-  const callbacks = options?.foreground
-    ? buildForegroundCallbacks()
-    : undefined;
-
-  logger.info(
-    `Daemon started ${new Date().toISOString()} for ${projectDir} (PID ${process.pid})`,
-  );
-  logger.info(`Tick interval: ${config.tick_interval_seconds}s`);
-
-  let tickNum = 0;
-  while (true) {
-    tickNum++;
-    let didWork = false;
-    try {
-      didWork = await tick(
-        projectDir,
-        dbPath,
-        config,
-        mcpxClient,
-        callbacks,
-        tickNum,
-      );
-    } catch (err) {
-      logger.error(`Tick failed: ${err}`);
-    }
-
-    if (!didWork) {
-      logger.phase("sleeping", `${config.tick_interval_seconds}s`);
-      await Bun.sleep(config.tick_interval_seconds * 1000);
-    }
-  }
-}

package/src/daemon/run.ts

@@ -1,14 +0,0 @@
-#!/usr/bin/env bun
-
-// Standalone entry point for the daemon when spawned as a detached process.
-// Usage: bun run src/daemon/run.ts <projectDir>
-
-import { startDaemon } from "./index.ts";
-
-const projectDir = process.argv[2];
-if (!projectDir) {
-  console.error("Usage: bun run src/daemon/run.ts <projectDir>");
-  process.exit(1);
-}
-
-await startDaemon(projectDir);

package/src/daemon/spawn.ts

@@ -1,38 +0,0 @@
-import { join } from "node:path";
-import { getBotholomewDir, getLogPath } from "../constants.ts";
-import { logger } from "../utils/logger.ts";
-import { isProcessAlive, readPidFile } from "../utils/pid.ts";
-
-export async function spawnDaemon(projectDir: string): Promise<void> {
-  // Check if already running
-  const existingPid = await readPidFile(projectDir);
-  if (existingPid && isProcessAlive(existingPid)) {
-    logger.warn(`Daemon already running (PID ${existingPid})`);
-    return;
-  }
-
-  // Ensure .botholomew dir exists
-  const dotDir = getBotholomewDir(projectDir);
-  const dirExists = await Bun.file(join(dotDir, "config.json")).exists();
-  if (!dirExists) {
-    logger.error("Project not initialized. Run 'botholomew init' first.");
-    process.exit(1);
-  }
-
-  const logPath = getLogPath(projectDir);
-  const logFile = Bun.file(logPath);
-
-  // Find the daemon entry script
-  const daemonScript = new URL("./run.ts", import.meta.url).pathname;
-
-  const proc = Bun.spawn(["bun", "run", daemonScript, projectDir], {
-    stdio: ["ignore", logFile, logFile],
-    env: { ...process.env },
-  });
-
-  // Detach the process
-  proc.unref();
-
-  logger.success(`Daemon started in background (PID ${proc.pid})`);
-  logger.dim(`  Log: ${logPath}`);
-}

package/src/daemon/watchdog.ts

@@ -1,306 +0,0 @@
-import { unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import {
-  getWatchdogLogPath,
-  LAUNCHD_LABEL_PREFIX,
-  SYSTEMD_UNIT_PREFIX,
-  sanitizePathForServiceName,
-} from "../constants.ts";
-import {
-  listRegisteredProjects,
-  registerProject,
-  unregisterProject,
-} from "../utils/project-registry.ts";
-
-export type Platform = "macos" | "linux";
-
-export function detectPlatform(): Platform {
-  if (process.platform === "darwin") return "macos";
-  if (process.platform === "linux") return "linux";
-  throw new Error(`Unsupported platform: ${process.platform}`);
-}
-
-function getServiceName(projectDir: string): string {
-  return sanitizePathForServiceName(resolve(projectDir));
-}
-
-function getHealthcheckCommand(projectDir: string): string[] {
-  const healthcheckScript = new URL("./healthcheck.ts", import.meta.url)
-    .pathname;
-  return ["bun", "run", healthcheckScript, resolve(projectDir)];
-}
-
-function getLaunchdLabel(projectDir: string): string {
-  return `${LAUNCHD_LABEL_PREFIX}${getServiceName(projectDir)}`;
-}
-
-function getLaunchdPlistPath(projectDir: string): string {
-  return join(
-    homedir(),
-    "Library",
-    "LaunchAgents",
-    `${getLaunchdLabel(projectDir)}.plist`,
-  );
-}
-
-function getSystemdBaseName(projectDir: string): string {
-  return `${SYSTEMD_UNIT_PREFIX}${getServiceName(projectDir)}`;
-}
-
-function getSystemdDir(): string {
-  return join(homedir(), ".config", "systemd", "user");
-}
-
-export function generateLaunchdPlist(
-  projectDir: string,
-  healthcheckCmd: string[],
-): string {
-  const absDir = resolve(projectDir);
-  const label = getLaunchdLabel(absDir);
-  const watchdogLog = getWatchdogLogPath(absDir);
-
-  const programArgs = healthcheckCmd
-    .map((arg) => `    <string>${escapeXml(arg)}</string>`)
-    .join("\n");
-
-  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>${escapeXml(label)}</string>
-  <key>ProgramArguments</key>
-  <array>
-${programArgs}
-  </array>
-  <key>StartInterval</key>
-  <integer>60</integer>
-  <key>KeepAlive</key>
-  <false/>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(watchdogLog)}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(watchdogLog)}</string>
-</dict>
-</plist>
-`;
-}
-
-export function generateSystemdService(
-  projectDir: string,
-  healthcheckCmd: string[],
-): string {
-  const absDir = resolve(projectDir);
-  return `[Unit]
-Description=Botholomew healthcheck for ${absDir}
-
-[Service]
-Type=oneshot
-ExecStart=${healthcheckCmd.join(" ")}
-
-[Install]
-WantedBy=default.target
-`;
-}
-
-export function generateSystemdTimer(serviceName: string): string {
-  return `[Unit]
-Description=Botholomew watchdog timer for ${serviceName}
-
-[Timer]
-OnBootSec=60
-OnUnitActiveSec=60
-
-[Install]
-WantedBy=timers.target
-`;
-}
-
-export function generateWatchdogConfig(projectDir: string): {
-  platform: Platform;
-  files: Array<{ path: string; content: string }>;
-} {
-  const absDir = resolve(projectDir);
-  const platform = detectPlatform();
-  const cmd = getHealthcheckCommand(absDir);
-
-  if (platform === "macos") {
-    return {
-      platform,
-      files: [
-        {
-          path: getLaunchdPlistPath(absDir),
-          content: generateLaunchdPlist(absDir, cmd),
-        },
-      ],
-    };
-  }
-
-  const baseName = getSystemdBaseName(absDir);
-  const systemdDir = getSystemdDir();
-  return {
-    platform,
-    files: [
-      {
-        path: join(systemdDir, `${baseName}.service`),
-        content: generateSystemdService(absDir, cmd),
-      },
-      {
-        path: join(systemdDir, `${baseName}.timer`),
-        content: generateSystemdTimer(baseName),
-      },
-    ],
-  };
-}
-
-export async function installWatchdog(projectDir: string): Promise<{
-  installed: boolean;
-  platform: Platform;
-  paths: string[];
-}> {
-  const absDir = resolve(projectDir);
-  const config = generateWatchdogConfig(absDir);
-  const paths: string[] = [];
-
-  for (const file of config.files) {
-    await Bun.write(file.path, file.content);
-    paths.push(file.path);
-  }
-
-  if (config.platform === "macos") {
-    const plistPath = config.files[0]?.path;
-    if (!plistPath) throw new Error("No plist file generated");
-    const proc = Bun.spawnSync(["launchctl", "load", plistPath]);
-    if (proc.exitCode !== 0) {
-      const stderr = proc.stderr.toString().trim();
-      throw new Error(`launchctl load failed: ${stderr}`);
-    }
-  } else {
-    const baseName = getSystemdBaseName(absDir);
-    const reload = Bun.spawnSync(["systemctl", "--user", "daemon-reload"]);
-    if (reload.exitCode !== 0) {
-      throw new Error(
-        `systemctl daemon-reload failed: ${reload.stderr.toString().trim()}`,
-      );
-    }
-    const enable = Bun.spawnSync([
-      "systemctl",
-      "--user",
-      "enable",
-      "--now",
-      `${baseName}.timer`,
-    ]);
-    if (enable.exitCode !== 0) {
-      throw new Error(
-        `systemctl enable failed: ${enable.stderr.toString().trim()}`,
-      );
-    }
-  }
-
-  await registerProject(absDir);
-
-  return { installed: true, platform: config.platform, paths };
-}
-
-export async function uninstallWatchdog(projectDir: string): Promise<{
-  removed: boolean;
-  platform: Platform;
-}> {
-  const absDir = resolve(projectDir);
-  const platform = detectPlatform();
-
-  if (platform === "macos") {
-    const plistPath = getLaunchdPlistPath(absDir);
-    const file = Bun.file(plistPath);
-    if (!(await file.exists())) {
-      return { removed: false, platform };
-    }
-    Bun.spawnSync(["launchctl", "unload", plistPath]);
-    try {
-      await unlink(plistPath);
-    } catch {
-      // ignore
-    }
-  } else {
-    const baseName = getSystemdBaseName(absDir);
-    Bun.spawnSync([
-      "systemctl",
-      "--user",
-      "disable",
-      "--now",
-      `${baseName}.timer`,
-    ]);
-    const systemdDir = getSystemdDir();
-    for (const ext of [".service", ".timer"]) {
-      try {
-        await unlink(join(systemdDir, `${baseName}${ext}`));
-      } catch {
-        // ignore
-      }
-    }
-    Bun.spawnSync(["systemctl", "--user", "daemon-reload"]);
-  }
-
-  await unregisterProject(absDir);
-
-  return { removed: true, platform };
-}
-
-export async function getWatchdogStatus(projectDir: string): Promise<{
-  installed: boolean;
-  platform: Platform;
-  configPath?: string;
-}> {
-  const absDir = resolve(projectDir);
-  const platform = detectPlatform();
-
-  if (platform === "macos") {
-    const plistPath = getLaunchdPlistPath(absDir);
-    const exists = await Bun.file(plistPath).exists();
-    return {
-      installed: exists,
-      platform,
-      configPath: exists ? plistPath : undefined,
-    };
-  }
-
-  const baseName = getSystemdBaseName(absDir);
-  const timerPath = join(getSystemdDir(), `${baseName}.timer`);
-  const exists = await Bun.file(timerPath).exists();
-  return {
-    installed: exists,
-    platform,
-    configPath: exists ? timerPath : undefined,
-  };
-}
-
-export async function listAllWatchdogProjects(): Promise<
-  Array<{ projectDir: string; configPath: string }>
-> {
-  const projects = await listRegisteredProjects();
-  const platform = detectPlatform();
-  const results: Array<{ projectDir: string; configPath: string }> = [];
-
-  for (const project of projects) {
-    let configPath: string;
-    if (platform === "macos") {
-      configPath = getLaunchdPlistPath(project.projectDir);
-    } else {
-      const baseName = getSystemdBaseName(project.projectDir);
-      configPath = join(getSystemdDir(), `${baseName}.timer`);
-    }
-    results.push({ projectDir: project.projectDir, configPath });
-  }
-
-  return results;
-}
-
-function escapeXml(str: string): string {
-  return str
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&apos;");
-}