@ailog/cli 0.2.3 → 0.3.0

package/dist/viewer/server.js

@@ -0,0 +1,413 @@
+// src/viewer/server.ts
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { streamSSE } from "hono/streaming";
+import path2 from "path";
+import fs2 from "fs";
+import { fileURLToPath } from "url";
+
+// src/db.ts
+import path from "path";
+import fs from "fs";
+var DB_DIR = path.join(process.cwd(), ".ailog");
+var RUNS_DIR = () => path.join(DB_DIR, "runs");
+var BLOBS_DIR = () => path.join(DB_DIR, "blobs");
+var RUN_INDEX_DIR = () => path.join(DB_DIR, "index", "runs");
+var THREAD_INDEX_DIR = () => path.join(DB_DIR, "index", "threads");
+var getDbDir = () => DB_DIR;
+var AILOG_PORT = process.env.AILOG_PORT ? parseInt(process.env.AILOG_PORT) : 4985;
+var dirResolved = false;
+var dirResolvePromise = null;
+var resolveDbDir = async () => {
+  if (dirResolved) return;
+  if (!dirResolvePromise) {
+    dirResolvePromise = (async () => {
+      try {
+        const res = await fetch(
+          `http://localhost:${AILOG_PORT}/api/db-dir`
+        );
+        if (res.ok) {
+          const body = await res.json();
+          if (typeof body.dir === "string" && body.dir.length > 0) {
+            DB_DIR = body.dir;
+          }
+        }
+      } catch {
+      } finally {
+        dirResolved = true;
+      }
+    })();
+  }
+  await dirResolvePromise;
+};
+var BLOB_THRESHOLD = 16 * 1024;
+var notifyServer = (event, runId) => {
+  notifyServerAsync(event, runId);
+};
+var notifyServerAsync = async (event, runId) => {
+  try {
+    await fetch(`http://localhost:${AILOG_PORT}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        event,
+        timestamp: Date.now(),
+        runId: runId ?? null
+      })
+    });
+  } catch {
+  }
+};
+var ensureGitignore = () => {
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  if (!fs.existsSync(gitignorePath)) return;
+  const content = fs.readFileSync(gitignorePath, "utf-8");
+  const alreadyIgnored = content.split("\n").some((line) => line.trim() === ".ailog" || line.trim() === ".ailog/");
+  if (!alreadyIgnored) {
+    const next = content.endsWith("\n") ? `${content}.ailog
+` : `${content}
+.ailog
+`;
+    fs.writeFileSync(gitignorePath, next);
+  }
+};
+var ensureLayout = () => {
+  const isFirstRun = !fs.existsSync(DB_DIR);
+  fs.mkdirSync(RUNS_DIR(), { recursive: true });
+  fs.mkdirSync(BLOBS_DIR(), { recursive: true });
+  fs.mkdirSync(RUN_INDEX_DIR(), { recursive: true });
+  fs.mkdirSync(THREAD_INDEX_DIR(), { recursive: true });
+  if (isFirstRun) ensureGitignore();
+};
+var safeReadJson = (filePath, fallback) => {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+};
+var readBlobIfPresent = (relPath) => {
+  const absolute = path.join(DB_DIR, relPath);
+  try {
+    if (!fs.existsSync(absolute)) return null;
+    return fs.readFileSync(absolute, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var isBlobRef = (v) => !!v && typeof v === "object" && "$blob" in v;
+var hydrate = (v) => {
+  if (v === null) return null;
+  if (typeof v === "string") return v;
+  if (isBlobRef(v)) return readBlobIfPresent(v.$blob);
+  return null;
+};
+var runCache = /* @__PURE__ */ new Map();
+var pageCache = /* @__PURE__ */ new Map();
+var PAGE_FILE_RE = /^\d{17}\.json$/;
+var listPageFiles = (dir) => {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter((n) => PAGE_FILE_RE.test(n)).sort().map((n) => path.join(dir, n));
+};
+var loadPage = (file) => {
+  const cached = pageCache.get(file);
+  if (cached) return cached;
+  const data = safeReadJson(file, []);
+  pageCache.set(file, data);
+  return data;
+};
+var loadPagedNewestFirst = (dir, offset, limit) => {
+  const files = listPageFiles(dir).reverse();
+  let total = 0;
+  for (const f of files) total += loadPage(f).length;
+  const items = [];
+  let skipped = 0;
+  for (const file of files) {
+    const page = loadPage(file);
+    for (let i = page.length - 1; i >= 0; i--) {
+      if (skipped < offset) {
+        skipped++;
+        continue;
+      }
+      items.push(page[i]);
+      if (items.length === limit) {
+        return {
+          items,
+          total,
+          hasMore: offset + items.length < total
+        };
+      }
+    }
+  }
+  return { items, total, hasMore: false };
+};
+var loadRunFile = (runId) => {
+  const cached = runCache.get(runId);
+  if (cached) return cached;
+  const file = safeReadJson(
+    path.join(RUNS_DIR(), `${runId}.json`),
+    null
+  );
+  if (!file) return null;
+  runCache.set(runId, file);
+  return file;
+};
+var reloadDb = async (runId) => {
+  pageCache.clear();
+  if (runId) {
+    runCache.delete(runId);
+  } else {
+    runCache.clear();
+  }
+};
+var hydrateStep = (s) => ({
+  ...s,
+  output: hydrate(s.output),
+  raw_request: hydrate(s.raw_request),
+  raw_response: hydrate(s.raw_response),
+  raw_chunks: hydrate(s.raw_chunks)
+});
+var getRunSummariesPage = async (offset, limit) => loadPagedNewestFirst(RUN_INDEX_DIR(), offset, limit);
+var getThreadsPage = async (offset, limit) => loadPagedNewestFirst(THREAD_INDEX_DIR(), offset, limit);
+var getRunWithSteps = async (runId) => {
+  const file = loadRunFile(runId);
+  if (!file) return null;
+  return {
+    run: file.run,
+    steps: [...file.steps].sort((a, b) => a.step_number - b.step_number).map(hydrateStep)
+  };
+};
+var clearDatabase = async () => {
+  await resolveDbDir();
+  ensureLayout();
+  fs.rmSync(path.join(DB_DIR, "index"), { recursive: true, force: true });
+  fs.rmSync(RUNS_DIR(), { recursive: true, force: true });
+  fs.rmSync(BLOBS_DIR(), { recursive: true, force: true });
+  fs.mkdirSync(RUN_INDEX_DIR(), { recursive: true });
+  fs.mkdirSync(THREAD_INDEX_DIR(), { recursive: true });
+  fs.mkdirSync(RUNS_DIR(), { recursive: true });
+  fs.mkdirSync(BLOBS_DIR(), { recursive: true });
+  runCache.clear();
+  pageCache.clear();
+  notifyServer("clear");
+};
+
+// src/viewer/server.ts
+var sseClients = /* @__PURE__ */ new Set();
+var broadcastToClients = (event, data) => {
+  const message = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  for (const client of sseClients) {
+    try {
+      client.controller.enqueue(message);
+    } catch {
+      sseClients.delete(client);
+    }
+  }
+};
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var devEnv = process.env.AILOG_DEV;
+var isDevMode = devEnv !== void 0 && devEnv !== "false" && devEnv !== "0";
+var projectRoot = path2.resolve(__dirname, "../..");
+var clientDir = path2.join(projectRoot, "dist/client");
+var app = new Hono();
+app.use("/*", cors());
+var parsePagination = (c) => {
+  const offset = Math.max(0, parseInt(c.req.query("offset") ?? "0", 10) || 0);
+  const limit = Math.min(
+    200,
+    Math.max(1, parseInt(c.req.query("limit") ?? "50", 10) || 50)
+  );
+  return { offset, limit };
+};
+app.get("/api/runs", async (c) => {
+  await reloadDb();
+  const { offset, limit } = parsePagination(c);
+  const page = await getRunSummariesPage(offset, limit);
+  const items = page.items.map((r) => ({
+    id: r.id,
+    started_at: r.started_at,
+    function_id: r.function_id,
+    thread_id: r.thread_id,
+    stepCount: r.step_count,
+    firstMessage: r.first_message ?? "No user message",
+    hasError: r.has_error,
+    isInProgress: r.is_in_progress,
+    type: r.type ?? void 0
+  }));
+  return c.json({ items, total: page.total, hasMore: page.hasMore });
+});
+app.get("/api/runs/:id", async (c) => {
+  const runId = c.req.param("id");
+  await reloadDb(runId);
+  const data = await getRunWithSteps(runId);
+  if (!data) {
+    return c.json({ error: "Run not found" }, 404);
+  }
+  const isInProgress = data.steps.some((s) => s.duration_ms === null && !s.error);
+  return c.json({
+    run: { ...data.run, isInProgress },
+    steps: data.steps
+  });
+});
+app.get("/api/threads", async (c) => {
+  await reloadDb();
+  const { offset, limit } = parsePagination(c);
+  return c.json(await getThreadsPage(offset, limit));
+});
+app.get("/api/db-dir", (c) => {
+  return c.json({ dir: getDbDir() });
+});
+app.post("/api/clear", async (c) => {
+  await clearDatabase();
+  return c.json({ success: true });
+});
+app.get("/api/events", (c) => {
+  return streamSSE(c, async (stream) => {
+    const clientId = crypto.randomUUID();
+    const client = {
+      id: clientId,
+      controller: null
+    };
+    await stream.writeSSE({
+      event: "connected",
+      data: JSON.stringify({ clientId })
+    });
+    const originalWrite = stream.writeSSE.bind(stream);
+    client.controller = {
+      enqueue: (message) => {
+        const lines = message.split("\n");
+        let event = "message";
+        let data = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            event = line.slice(7);
+          } else if (line.startsWith("data: ")) {
+            data = line.slice(6);
+          }
+        }
+        originalWrite({ event, data }).catch(() => {
+        });
+      }
+    };
+    sseClients.add(client);
+    const heartbeat = setInterval(async () => {
+      try {
+        await stream.writeSSE({
+          event: "heartbeat",
+          data: JSON.stringify({ time: Date.now() })
+        });
+      } catch {
+        clearInterval(heartbeat);
+      }
+    }, 3e4);
+    try {
+      while (true) {
+        await stream.sleep(1e3);
+      }
+    } finally {
+      clearInterval(heartbeat);
+      sseClients.delete(client);
+    }
+  });
+});
+app.post("/api/notify", async (c) => {
+  const body = await c.req.json();
+  await reloadDb(body.runId ?? void 0);
+  broadcastToClients("update", body);
+  return c.json({ success: true });
+});
+app.use(
+  "/assets/*",
+  serveStatic({
+    root: clientDir.replace(/\/+$/, "")
+  })
+);
+app.get("*", async (c) => {
+  if (isDevMode) {
+    return c.html(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <meta charset="UTF-8">
+          <title>ailog</title>
+          <style>
+            body { font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa; }
+            .container { text-align: center; }
+            a { color: #3b82f6; text-decoration: none; font-size: 1.25rem; }
+            a:hover { text-decoration: underline; }
+            p { color: #737373; margin-top: 1rem; }
+          </style>
+        </head>
+        <body>
+          <div class="container">
+            <h2>Development Mode</h2>
+            <a href="http://localhost:5173">Open ailog UI \u2192</a>
+            <p>This port (4985) only serves the API in dev mode.</p>
+          </div>
+        </body>
+      </html>
+    `);
+  }
+  const indexPath = path2.join(clientDir, "index.html");
+  try {
+    const html = fs2.readFileSync(indexPath, "utf-8");
+    return c.html(html);
+  } catch {
+    return c.text("ailog client not built. Run `bun run build` first.", 500);
+  }
+});
+var startViewer = (port = 4985) => {
+  const server = serve(
+    {
+      fetch: app.fetch,
+      port
+    },
+    () => {
+      if (isDevMode) {
+        console.log(`\u{1F50D} ailog API running on port ${port}`);
+        console.log(`   Open http://localhost:5173 for the dev UI`);
+      } else {
+        console.log(`\u{1F50D} ailog running at http://localhost:${port}`);
+      }
+      console.log(`   Reading .ailog from ${getDbDir()}`);
+    }
+  );
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error(`
+\u274C Port ${port} is already in use.`);
+      console.error(
+        `
+   This likely means ailog is already running.`
+      );
+      console.error(`   Open http://localhost:${port} in your browser.
+`);
+      console.error(`   To use a different port, set AILOG_PORT:
+`);
+      console.error(`   AILOG_PORT=4986 npx ailog
+`);
+      process.exit(1);
+    }
+    throw err;
+  });
+};
+var currentFile = fileURLToPath(import.meta.url);
+var isDirectRun = process.argv[1] === currentFile || process.argv[1]?.endsWith("/server.ts") || process.argv[1]?.endsWith("/server.js");
+if (isDirectRun) {
+  const port = process.env.AILOG_PORT ? parseInt(process.env.AILOG_PORT) : 4985;
+  startViewer(port);
+}
+export {
+  startViewer
+};

package/package.json

@@ -1,66 +1,86 @@
 {
   "name": "@ailog/cli",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "CLI to run the ailog LLM logging dashboard",
-  "private": false,
   "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "bin": {
-    "ailog": "./dist/bin/cli.js"
+    "ailog": "./bin/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin",
+    "NOTICE"
   ],
   "scripts": {
-    "dev": "next dev --port 9000",
-    "build": "next build",
-    "build:cli": "next build && bun scripts/build-cli.ts",
-    "start": "next start",
-    "start:cli": "node dist/bin/cli.js start",
-    "prepublishOnly": "bun run build:cli",
-    "lint": "eslint --max-warnings=0 .",
-    "lint:fix": "eslint --fix ."
+    "dev": "concurrently -k \"bun run dev:api\" \"bun run dev:client\"",
+    "dev:api": "AILOG_DEV=true tsx src/viewer/server.ts",
+    "dev:client": "vite",
+    "start": "node dist/viewer/server.js",
+    "build": "bun run build:client && bun run build:server",
+    "build:client": "vite build",
+    "build:server": "tsup --tsconfig tsconfig.build.json",
+    "test": "vitest --config vitest.node.config.js --run",
+    "test:watch": "vitest --config vitest.node.config.js",
+    "check-types": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
   },
-  "dependencies": {
-    "@swc/helpers": "^0.5.15",
-    "client-only": "^0.0.1",
-    "commander": "^12.0.0",
-    "next": "16.0.10",
-    "pg": "^8.16.3",
-    "react": "19.2.1",
-    "react-dom": "19.2.1",
-    "styled-jsx": "^5.1.6",
-    "zod": "^4.3.0"
+  "peerDependencies": {
+    "ai": ">=7.0.0-beta"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    }
   },
-  "optionalDependencies": {
-    "sharp": "^0.34.5"
+  "dependencies": {
+    "@ai-sdk/provider": "4.0.0-beta.14",
+    "@hono/node-server": "^1.13.7",
+    "hono": "^4.6.14"
   },
   "devDependencies": {
-    "@ailog/server": "*",
-    "@base-ui/react": "^1.0.0",
-    "@hugeicons/core-free-icons": "^2.0.0",
-    "@hugeicons/react": "^1.1.1",
-    "@tailwindcss/postcss": "^4",
-    "@tanstack/react-table": "^8.21.3",
-    "@types/bun": "^1.3.5",
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
+    "@radix-ui/react-collapsible": "^1.1.12",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-slot": "^1.2.4",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "@tailwindcss/vite": "^4.1.17",
+    "@types/node": "^20.17.24",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "@vitejs/plugin-react": "^4.3.4",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "eslint": "^9",
-    "eslint-config-next": "16.0.10",
-    "hono": "^4.11.0",
-    "next-themes": "^0.4.6",
-    "nuqs": "^2.8.5",
-    "radix-ui": "^1.4.3",
-    "shadcn": "^3.6.1",
-    "sonner": "^2.0.7",
+    "concurrently": "^9.1.0",
+    "lucide-react": "^0.556.0",
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19",
     "tailwind-merge": "^3.4.0",
-    "tailwindcss": "^4",
+    "tailwindcss": "^4.1.17",
+    "tsup": "^8",
+    "tsx": "^4.19.2",
     "tw-animate-css": "^1.4.0",
-    "typescript": "^5"
+    "typescript": "5.8.3",
+    "vaul": "^1.1.2",
+    "vite": "^6.0.3",
+    "vitest": "^4.1.5",
+    "zod": "^3.25.0"
   },
   "engines": {
     "node": ">=18"
-  }
+  },
+  "sideEffects": false,
+  "license": "Apache-2.0"
 }