server.ts

import { Subprocess } from "bun";
import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
import { join, dirname } from "path";

interface ProjectConfig {
  name: string;
  path: string;
}

interface Config {
  port: number;
  projects: ProjectConfig[];
}

interface RunningProject {
  name: string;
  path: string;
  port: number;
  process: Subprocess;
}

const configPath = join(import.meta.dir, "config.json");
const config: Config = JSON.parse(readFileSync(configPath, "utf-8"));
const dashboardPort = config.port || 6420;

const running: RunningProject[] = [];
const configuredProjects: ProjectConfig[] = [...config.projects];

function nextPort(): number {
  if (running.length === 0) return dashboardPort + 1;
  return Math.max(...running.map((r) => r.port)) + 1;
}

function spawnProject(name: string, path: string): RunningProject {
  const port = nextPort();
  console.log(`Starting backlog for "${name}" on port ${port} (cwd: ${path})`);

  const proc = Bun.spawn(["backlog", "browser", "--port", String(port), "--no-open"], {
    cwd: path,
    stdout: "ignore",
    stderr: "pipe",
  });

  const entry: RunningProject = { name, path, port, process: proc };
  running.push(entry);
  return entry;
}

function saveConfig() {
  const data: Config = {
    port: dashboardPort,
    projects: configuredProjects,
  };
  writeFileSync(configPath, JSON.stringify(data, null, 2) + "\n");
}

// Spawn backlog browser for each project
for (const project of config.projects) {
  spawnProject(project.name, project.path);
}

// Wait for instances to start
await Bun.sleep(1500);

// Serve dashboard
const indexPath = join(import.meta.dir, "index.html");

const server = Bun.serve({
  port: dashboardPort,
  async fetch(req) {
    const url = new URL(req.url);

    if (url.pathname === "/" || url.pathname === "/index.html") {
      return new Response(readFileSync(indexPath, "utf-8"), {
        headers: { "Content-Type": "text/html" },
      });
    }

    if (url.pathname === "/api/projects" && req.method === "GET") {
      // Return in config order
      const projects = configuredProjects.map((cfg) => {
        const r = running.find((r) => r.name === cfg.name && r.path === cfg.path);
        return { name: cfg.name, port: r?.port ?? 0, path: cfg.path };
      });
      return Response.json(projects);
    }

    if (url.pathname === "/api/projects" && req.method === "POST") {
      const body = await req.json() as { name?: string; path?: string };
      if (!body.name || !body.path) {
        return Response.json({ error: "name and path are required" }, { status: 400 });
      }
      const entry = spawnProject(body.name, body.path);
      configuredProjects.push({ name: body.name, path: body.path });
      saveConfig();
      await Bun.sleep(1500);
      return Response.json({ name: entry.name, port: entry.port, path: entry.path });
    }

    if (url.pathname.startsWith("/api/projects/") && req.method === "DELETE") {
      const port = Number(url.pathname.split("/").pop());
      const idx = running.findIndex((r) => r.port === port);
      if (idx === -1) {
        return Response.json({ error: "project not found" }, { status: 404 });
      }
      const removed = running[idx];
      console.log(`Removing project "${removed.name}" (port ${port})`);
      removed.process.kill();
      running.splice(idx, 1);
      const cfgIdx = configuredProjects.findIndex((p) => p.name === removed.name && p.path === removed.path);
      if (cfgIdx !== -1) configuredProjects.splice(cfgIdx, 1);
      saveConfig();
      return Response.json({ ok: true });
    }

    if (url.pathname.match(/^\/api\/projects\/\d+\/restart$/) && req.method === "POST") {
      const port = Number(url.pathname.split("/")[3]);
      const idx = running.findIndex((r) => r.port === port);
      if (idx === -1) {
        return Response.json({ error: "project not found" }, { status: 404 });
      }
      const old = running[idx];
      console.log(`Restarting backlog for "${old.name}" (port ${port})`);
      old.process.kill();
      running.splice(idx, 1);
      const entry = spawnProject(old.name, old.path);
      await Bun.sleep(1500);
      return Response.json({ name: entry.name, port: entry.port, path: entry.path });
    }

    if (url.pathname === "/api/projects/reorder" && req.method === "PUT") {
      const body = await req.json() as { order: number[] };
      if (!body.order || !Array.isArray(body.order)) {
        return Response.json({ error: "order array is required" }, { status: 400 });
      }
      const reordered = body.order.map((port) => {
        const r = running.find((r) => r.port === port);
        return r ? { name: r.name, path: r.path } : null;
      }).filter(Boolean) as ProjectConfig[];
      if (reordered.length !== configuredProjects.length) {
        return Response.json({ error: "order must include all projects" }, { status: 400 });
      }
      configuredProjects.splice(0, configuredProjects.length, ...reordered);
      saveConfig();
      return Response.json({ ok: true });
    }

    if (url.pathname === "/api/browse") {
      const dir = url.searchParams.get("dir") || "C:/";
      try {
        const entries = readdirSync(dir, { withFileTypes: true });
        const dirs = entries
          .filter((e) => e.isDirectory() && !e.name.startsWith("."))
          .map((e) => e.name)
          .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
        const parent = dirname(dir) !== dir ? dirname(dir) : null;
        return Response.json({ dir, parent, dirs });
      } catch {
        return Response.json({ dir, parent: dirname(dir), dirs: [], error: "Cannot read directory" });
      }
    }

    if (url.pathname.startsWith("/api/health/")) {
      const port = url.pathname.split("/").pop();
      try {
        const res = await fetch(`http://localhost:${port}/`);
        return Response.json({ ok: res.ok });
      } catch {
        return Response.json({ ok: false });
      }
    }

    return new Response("Not found", { status: 404 });
  },
});

console.log(`\nBacklog Hub running at http://localhost:${dashboardPort}`);
console.log(`Managing ${running.length} project(s)\n`);

// Graceful shutdown
function shutdown() {
  console.log("\nShutting down...");
  for (const r of running) {
    console.log(`  Killing backlog for "${r.name}" (port ${r.port})`);
    r.process.kill();
  }
  server.stop();
  process.exit(0);
}

process.on("SIGINT", shutdown);
process.on("SIGTERM", shutdown);