@ailog/cli 0.2.2 → 0.2.6

package/dist/viewer/server.js

@@ -0,0 +1,360 @@
+// 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 INDEX_PATH = path.join(DB_DIR, "index.json");
+var RUNS_DIR = path.join(DB_DIR, "runs");
+var BLOBS_DIR = path.join(DB_DIR, "blobs");
+var AILOG_PORT = process.env.AILOG_PORT ? parseInt(process.env.AILOG_PORT) : 4985;
+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(),
+        dbPath: INDEX_PATH,
+        runId: runId ?? null
+      })
+    });
+  } catch {
+  }
+};
+var EMPTY_INDEX = () => ({
+  version: 1,
+  runs: [],
+  threads: []
+});
+var normalizeIndex = (raw) => ({
+  version: 1,
+  runs: raw.runs ?? [],
+  threads: raw.threads ?? []
+});
+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 });
+  if (isFirstRun) ensureGitignore();
+};
+var atomicWrite = (filePath, data) => {
+  ensureLayout();
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 6)}.tmp`;
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, filePath);
+};
+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(currentDbDir(), 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 indexCache = null;
+var runCache = /* @__PURE__ */ new Map();
+var remoteDbDir = null;
+var currentDbDir = () => remoteDbDir ?? DB_DIR;
+var currentIndexPath = () => path.join(currentDbDir(), "index.json");
+var currentRunPath = (runId) => path.join(currentDbDir(), "runs", `${runId}.json`);
+var loadIndex = () => {
+  if (indexCache) return indexCache;
+  indexCache = normalizeIndex(
+    safeReadJson(currentIndexPath(), EMPTY_INDEX())
+  );
+  return indexCache;
+};
+var loadRunFile = (runId) => {
+  const cached = runCache.get(runId);
+  if (cached) return cached;
+  const file = safeReadJson(currentRunPath(runId), null);
+  if (!file) return null;
+  runCache.set(runId, file);
+  return file;
+};
+var reloadDb = async (remoteIndexPath, runId) => {
+  if (remoteIndexPath) {
+    remoteDbDir = path.dirname(remoteIndexPath);
+  }
+  indexCache = null;
+  if (runId) {
+    runCache.delete(runId);
+  } else {
+    runCache.clear();
+  }
+  loadIndex();
+};
+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 getRunSummaries = async () => {
+  const index = loadIndex();
+  return [...index.runs].sort(
+    (a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime()
+  );
+};
+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 () => {
+  ensureLayout();
+  fs.rmSync(RUNS_DIR, { recursive: true, force: true });
+  fs.rmSync(BLOBS_DIR, { recursive: true, force: true });
+  fs.mkdirSync(RUNS_DIR, { recursive: true });
+  fs.mkdirSync(BLOBS_DIR, { recursive: true });
+  runCache.clear();
+  indexCache = EMPTY_INDEX();
+  atomicWrite(INDEX_PATH, JSON.stringify(indexCache, null, 2));
+  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 remoteDbPath;
+var app = new Hono();
+app.use("/*", cors());
+app.get("/api/runs", async (c) => {
+  await reloadDb(remoteDbPath);
+  const summaries = await getRunSummaries();
+  const runs = summaries.map((r) => ({
+    id: r.id,
+    started_at: r.started_at,
+    function_id: r.function_id,
+    metadata: r.metadata,
+    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(runs);
+});
+app.get("/api/runs/:id", async (c) => {
+  const runId = c.req.param("id");
+  await reloadDb(remoteDbPath, 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.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();
+  if (body.dbPath) {
+    remoteDbPath = body.dbPath;
+  }
+  await reloadDb(remoteDbPath, 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}`);
+      }
+    }
+  );
+  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.2",
+  "version": "0.2.6",
   "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"
 }