@alexzeitler/session-md 0.5.0

package/src/index.ts

@@ -0,0 +1,282 @@
+#!/usr/bin/env bun
+
+import { createCliRenderer } from "@opentui/core";
+import { loadConfig } from "./config.ts";
+import { App } from "./app.ts";
+import { scanClaudeCodeSessions } from "./import/claude-code-to-md.ts";
+import { scanOpencodeSessions } from "./import/opencode-to-md.ts";
+import { scanMemorizerMemories } from "./import/memorizer-to-md.ts";
+import { importClaudeExport } from "./import/claude-export-to-md.ts";
+import type { SessionEntry } from "./import/types.ts";
+import { SearchIndex, deleteIndex } from "./search/index.ts";
+import { loadTheme } from "./theme.ts";
+
+const { version } = require("../package.json");
+
+if (process.argv.includes("--version")) {
+  console.log(`session-md v${version}`);
+  process.exit(0);
+}
+
+const command = process.argv[2];
+
+if (command === "update") {
+  const oldVersion = version;
+  console.log(`Current version: v${oldVersion}`);
+  console.log("Checking for updates...");
+
+  try {
+    const res = await fetch("https://registry.npmjs.org/@alexzeitler/session-md/latest");
+    if (!res.ok) {
+      console.error(`Failed to check for updates (HTTP ${res.status})`);
+      process.exit(1);
+    }
+    const pkg = await res.json() as { version: string };
+    const latestVersion = pkg.version;
+
+    if (latestVersion === oldVersion) {
+      console.log(`✓ session-md v${oldVersion} is already up to date`);
+      process.exit(0);
+    }
+
+    console.log(`New version available: v${latestVersion}`);
+    console.log("Installing...");
+
+    const proc = Bun.spawnSync({
+      cmd: ["bun", "install", "-g", "@alexzeitler/session-md@" + latestVersion],
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+
+    if (proc.exitCode !== 0) {
+      console.error("Update failed");
+      process.exit(proc.exitCode ?? 1);
+    }
+
+    console.log(`✓ Updated session-md v${oldVersion} → v${latestVersion}`);
+  } catch (err) {
+    console.error(`Update failed: ${err}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+if (command === "reindex") {
+  deleteIndex();
+  console.log("✓ Search index deleted, will rebuild on next start.");
+  process.exit(0);
+}
+
+// --- MCP subcommand ---
+if (command === "mcp") {
+  const sub = process.argv[3];
+  const args = process.argv.slice(3);
+  const hasFlag = (f: string) => args.includes(f);
+  const getFlagValue = (f: string) => {
+    const idx = args.indexOf(f);
+    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined;
+  };
+
+  const { resolve } = await import("path");
+  const { homedir } = await import("os");
+  const { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, openSync, closeSync } = await import("fs");
+  const { spawn: nodeSpawn } = await import("child_process");
+  const { fileURLToPath } = await import("url");
+
+  const cacheDir = process.env.XDG_CACHE_HOME
+    ? resolve(process.env.XDG_CACHE_HOME, "session-md")
+    : resolve(homedir(), ".cache", "session-md");
+  const pidPath = resolve(cacheDir, "mcp.pid");
+
+  if (sub === "stop") {
+    if (!existsSync(pidPath)) {
+      console.log("Not running (no PID file).");
+      process.exit(0);
+    }
+    const pid = parseInt(readFileSync(pidPath, "utf-8").trim());
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGTERM");
+      unlinkSync(pidPath);
+      console.log(`Stopped session-md MCP server (PID ${pid}).`);
+    } catch {
+      unlinkSync(pidPath);
+      console.log("Cleaned up stale PID file (server was not running).");
+    }
+    process.exit(0);
+  }
+
+  if (hasFlag("--http")) {
+    const port = Number(getFlagValue("--port")) || 8282;
+
+    if (hasFlag("--daemon")) {
+      // Guard: check if already running
+      if (existsSync(pidPath)) {
+        const existingPid = parseInt(readFileSync(pidPath, "utf-8").trim());
+        try {
+          process.kill(existingPid, 0);
+          console.error(`Already running (PID ${existingPid}). Run 'session-md mcp stop' first.`);
+          process.exit(1);
+        } catch {
+          // Stale PID file — continue
+        }
+      }
+
+      mkdirSync(cacheDir, { recursive: true });
+      const logPath = resolve(cacheDir, "mcp.log");
+      const logFd = openSync(logPath, "w");
+      const selfPath = fileURLToPath(import.meta.url);
+      const child = nodeSpawn(process.execPath, [selfPath, "mcp", "--http", "--port", String(port)], {
+        stdio: ["ignore", logFd, logFd],
+        detached: true,
+      });
+      child.unref();
+      closeSync(logFd);
+
+      writeFileSync(pidPath, String(child.pid));
+      console.log(`Started on http://localhost:${port}/mcp (PID ${child.pid})`);
+      console.log(`Logs: ${logPath}`);
+      process.exit(0);
+    }
+
+    // Foreground HTTP mode
+    const { startMcpHttpServer } = await import("./mcp/http.ts");
+    try {
+      await startMcpHttpServer(port);
+    } catch (e: any) {
+      if (e?.code === "EADDRINUSE") {
+        console.error(`Port ${port} already in use. Try a different port with --port.`);
+        process.exit(1);
+      }
+      throw e;
+    }
+  } else {
+    // Default: stdio transport
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const { createMcpServer, createSessionStore } = await import("./mcp/server.ts");
+    const store = await createSessionStore();
+    const server = await createMcpServer(store);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  }
+
+  // Block forever — HTTP server and stdio transport keep the process alive
+  // via the event loop; this prevents falling through to the TUI code below.
+  await new Promise(() => {});
+}
+
+const SPINNER_FRAMES = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+
+function printSpinner(frame: number, msg: string): void {
+  process.stdout.write(`\r${SPINNER_FRAMES[frame % SPINNER_FRAMES.length]} ${msg}`);
+}
+
+function clearLine(): void {
+  process.stdout.write("\r\x1b[K");
+}
+
+const config = await loadConfig();
+
+// Phase 1: Collect all sessions (CLI, before TUI)
+const allSessions: SessionEntry[] = [];
+let spinnerFrame = 0;
+
+printSpinner(spinnerFrame++, "Scanning sources...");
+
+if (config.sources.claude_code) {
+  try {
+    const entries = scanClaudeCodeSessions(config.sources.claude_code);
+    allSessions.push(...entries);
+    printSpinner(spinnerFrame++, `Scanned claude-code: ${entries.length} sessions`);
+  } catch {
+    // Silently skip
+  }
+}
+
+if (config.sources.opencode) {
+  try {
+    const entries = scanOpencodeSessions(config.sources.opencode);
+    allSessions.push(...entries);
+    printSpinner(spinnerFrame++, `Scanned opencode: ${entries.length} sessions`);
+  } catch {
+    // Silently skip
+  }
+}
+
+// Async sources
+const asyncLoaders: Promise<SessionEntry[]>[] = [];
+
+if (config.sources.memorizer_url) {
+  asyncLoaders.push(
+    scanMemorizerMemories(config.sources.memorizer_url).catch(() => []),
+  );
+}
+
+if (config.sources.claude_export) {
+  asyncLoaders.push(
+    importClaudeExport(config.sources.claude_export).catch(() => []),
+  );
+}
+
+if (asyncLoaders.length > 0) {
+  printSpinner(spinnerFrame++, "Loading async sources...");
+  const results = await Promise.all(asyncLoaders);
+  for (const entries of results) {
+    allSessions.push(...entries);
+  }
+}
+
+allSessions.sort(
+  (a, b) =>
+    new Date(b.meta.created_at).getTime() -
+    new Date(a.meta.created_at).getTime(),
+);
+
+printSpinner(spinnerFrame++, `${allSessions.length} sessions total. Indexing...`);
+
+// Phase 2: Build/update search index
+const searchIndex = new SearchIndex();
+
+const spinnerInterval = setInterval(() => {
+  // Keep spinner animation alive during indexing
+  spinnerFrame++;
+}, 80);
+
+const indexed = searchIndex.indexSessions(allSessions, (current, total) => {
+  printSpinner(spinnerFrame++, `Indexing ${current}/${total}...`);
+});
+
+// Cleanup stale entries
+const validIds = new Set(allSessions.map((s) => s.meta.id));
+const removed = searchIndex.cleanup(validIds);
+
+clearInterval(spinnerInterval);
+
+if (indexed > 0 || removed > 0) {
+  clearLine();
+  console.log(`✓ Indexed ${indexed} new/updated, removed ${removed} stale entries`);
+} else {
+  clearLine();
+  console.log(`✓ Search index up to date (${allSessions.length} sessions)`);
+}
+
+// Phase 3: Start TUI
+let renderer: Awaited<ReturnType<typeof createCliRenderer>> | null = null;
+
+try {
+  renderer = await createCliRenderer({
+    exitOnCtrlC: true,
+  });
+
+  const theme = loadTheme(config.theme);
+  const app = new App(renderer, config, searchIndex, theme);
+  await app.start();
+  app.loadSessions(allSessions);
+} catch (err) {
+  if (renderer) {
+    renderer.destroy();
+  }
+  searchIndex.close();
+  console.error("Failed to start session-md:", err);
+  process.exit(1);
+}

package/src/mcp/http.ts

@@ -0,0 +1,264 @@
+/**
+ * session-md MCP HTTP Transport
+ *
+ * Streamable HTTP server with session management, health endpoint,
+ * and daemon support. Pattern follows qmd's implementation.
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { createMcpServer, createSessionStore, type SessionStore } from "./server.ts";
+
+export type HttpServerHandle = {
+  httpServer: import("http").Server;
+  port: number;
+  stop: () => Promise<void>;
+};
+
+export async function startMcpHttpServer(
+  port: number,
+  options?: { quiet?: boolean },
+): Promise<HttpServerHandle> {
+  const store = await createSessionStore();
+
+  const sessions = new Map<string, WebStandardStreamableHTTPServerTransport>();
+
+  async function createSession(): Promise<WebStandardStreamableHTTPServerTransport> {
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID(),
+      enableJsonResponse: true,
+      onsessioninitialized: (sessionId: string) => {
+        sessions.set(sessionId, transport);
+        log(`${ts()} New session ${sessionId} (${sessions.size} active)`);
+      },
+    });
+    const server = await createMcpServer(store);
+    await server.connect(transport);
+
+    transport.onclose = () => {
+      if (transport.sessionId) {
+        sessions.delete(transport.sessionId);
+      }
+    };
+
+    return transport;
+  }
+
+  const startTime = Date.now();
+  const quiet = options?.quiet ?? false;
+
+  function ts(): string {
+    return new Date().toISOString().slice(11, 23);
+  }
+
+  function describeRequest(body: any): string {
+    const method = body?.method ?? "unknown";
+    if (method === "tools/call") {
+      const tool = body.params?.name ?? "?";
+      const args = body.params?.arguments;
+      if (args?.query) {
+        const q = String(args.query).slice(0, 80);
+        return `tools/call ${tool} "${q}"`;
+      }
+      if (args?.id) return `tools/call ${tool} ${args.id}`;
+      return `tools/call ${tool}`;
+    }
+    return method;
+  }
+
+  function log(msg: string): void {
+    if (!quiet) console.error(msg);
+  }
+
+  async function collectBody(req: IncomingMessage): Promise<string> {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) chunks.push(chunk as Buffer);
+    return Buffer.concat(chunks).toString();
+  }
+
+  const httpServer = createServer(
+    async (nodeReq: IncomingMessage, nodeRes: ServerResponse) => {
+      const reqStart = Date.now();
+      const pathname = nodeReq.url || "/";
+
+      try {
+        // GET /health
+        if (pathname === "/health" && nodeReq.method === "GET") {
+          const body = JSON.stringify({
+            status: "ok",
+            uptime: Math.floor((Date.now() - startTime) / 1000),
+            sessions: sessions.size,
+            indexed: store.sessions.length,
+          });
+          nodeRes.writeHead(200, { "Content-Type": "application/json" });
+          nodeRes.end(body);
+          log(`${ts()} GET /health (${Date.now() - reqStart}ms)`);
+          return;
+        }
+
+        // POST /mcp — MCP Streamable HTTP
+        if (pathname === "/mcp" && nodeReq.method === "POST") {
+          const rawBody = await collectBody(nodeReq);
+          const body = JSON.parse(rawBody);
+          const label = describeRequest(body);
+          const url = `http://localhost:${port}${pathname}`;
+          const headers: Record<string, string> = {};
+          for (const [k, v] of Object.entries(nodeReq.headers)) {
+            if (typeof v === "string") headers[k] = v;
+          }
+
+          const sessionId = headers["mcp-session-id"];
+          let transport: WebStandardStreamableHTTPServerTransport;
+
+          if (sessionId) {
+            const existing = sessions.get(sessionId);
+            if (!existing) {
+              nodeRes.writeHead(404, { "Content-Type": "application/json" });
+              nodeRes.end(
+                JSON.stringify({
+                  jsonrpc: "2.0",
+                  error: { code: -32001, message: "Session not found" },
+                  id: body?.id ?? null,
+                }),
+              );
+              return;
+            }
+            transport = existing;
+          } else if (isInitializeRequest(body)) {
+            transport = await createSession();
+          } else {
+            nodeRes.writeHead(400, { "Content-Type": "application/json" });
+            nodeRes.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32000,
+                  message: "Bad Request: Missing session ID",
+                },
+                id: body?.id ?? null,
+              }),
+            );
+            return;
+          }
+
+          const request = new Request(url, {
+            method: "POST",
+            headers,
+            body: rawBody,
+          });
+          const response = await transport.handleRequest(request, {
+            parsedBody: body,
+          });
+
+          nodeRes.writeHead(
+            response.status,
+            Object.fromEntries(response.headers),
+          );
+          nodeRes.end(Buffer.from(await response.arrayBuffer()));
+          log(`${ts()} POST /mcp ${label} (${Date.now() - reqStart}ms)`);
+          return;
+        }
+
+        // GET/DELETE /mcp — session-bound
+        if (pathname === "/mcp") {
+          const headers: Record<string, string> = {};
+          for (const [k, v] of Object.entries(nodeReq.headers)) {
+            if (typeof v === "string") headers[k] = v;
+          }
+
+          const sessionId = headers["mcp-session-id"];
+          if (!sessionId) {
+            nodeRes.writeHead(400, { "Content-Type": "application/json" });
+            nodeRes.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32000,
+                  message: "Bad Request: Missing session ID",
+                },
+                id: null,
+              }),
+            );
+            return;
+          }
+
+          const transport = sessions.get(sessionId);
+          if (!transport) {
+            nodeRes.writeHead(404, { "Content-Type": "application/json" });
+            nodeRes.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Session not found" },
+                id: null,
+              }),
+            );
+            return;
+          }
+
+          const url = `http://localhost:${port}${pathname}`;
+          const rawBody =
+            nodeReq.method !== "GET" && nodeReq.method !== "HEAD"
+              ? await collectBody(nodeReq)
+              : undefined;
+          const request = new Request(url, {
+            method: nodeReq.method || "GET",
+            headers,
+            ...(rawBody ? { body: rawBody } : {}),
+          });
+          const response = await transport.handleRequest(request);
+          nodeRes.writeHead(
+            response.status,
+            Object.fromEntries(response.headers),
+          );
+          nodeRes.end(Buffer.from(await response.arrayBuffer()));
+          return;
+        }
+
+        nodeRes.writeHead(404);
+        nodeRes.end("Not Found");
+      } catch (err) {
+        console.error("HTTP handler error:", err);
+        nodeRes.writeHead(500);
+        nodeRes.end("Internal Server Error");
+      }
+    },
+  );
+
+  await new Promise<void>((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, "localhost", () => resolve());
+  });
+
+  const actualPort = (httpServer.address() as import("net").AddressInfo).port;
+
+  let stopping = false;
+  const stop = async () => {
+    if (stopping) return;
+    stopping = true;
+    for (const transport of sessions.values()) {
+      await transport.close();
+    }
+    sessions.clear();
+    httpServer.close();
+    store.searchIndex.close();
+  };
+
+  process.on("SIGTERM", async () => {
+    console.error("Shutting down (SIGTERM)...");
+    await stop();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    console.error("Shutting down (SIGINT)...");
+    await stop();
+    process.exit(0);
+  });
+
+  log(
+    `session-md MCP server listening on http://localhost:${actualPort}/mcp`,
+  );
+  return { httpServer, port: actualPort, stop };
+}