@ailog/cli 0.2.6 → 0.3.0

package/dist/index.js

@@ -2,10 +2,36 @@
 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 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 PAGE_SIZE = 50;
 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);
@@ -18,29 +44,18 @@ var notifyServerAsync = async (event, runId) => {
       body: JSON.stringify({
         event,
         timestamp: Date.now(),
-        dbPath: INDEX_PATH,
         runId: runId ?? null
       })
     });
   } catch {
   }
 };
+var digitTimestamp = (date) => date.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
 var generateRunId = () => {
-  const now = /* @__PURE__ */ new Date();
-  const timestamp = now.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
+  const timestamp = digitTimestamp(/* @__PURE__ */ new Date());
   const uniqueId = crypto.randomUUID().slice(0, 8);
   return `${timestamp}-${uniqueId}`;
 };
-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;
@@ -56,8 +71,10 @@ var ensureGitignore = () => {
 };
 var ensureLayout = () => {
   const isFirstRun = !fs.existsSync(DB_DIR);
-  fs.mkdirSync(RUNS_DIR, { recursive: true });
-  fs.mkdirSync(BLOBS_DIR, { recursive: true });
+  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 atomicWrite = (filePath, data) => {
@@ -86,34 +103,86 @@ var externalizeIfLarge = (value, stepId, field) => {
   writeBlob(rel, value);
   return { $blob: rel };
 };
-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 pageCache = /* @__PURE__ */ new Map();
+var PAGE_FILE_RE = /^\d{17}\.json$/;
+var nextPageFilePath = (dir) => {
+  let nowMs = Date.now();
+  const files = listPageFiles(dir);
+  if (files.length > 0) {
+    const latestName = path.basename(files[files.length - 1], ".json");
+    const latestMs = parseDigitTimestamp(latestName);
+    if (Number.isFinite(latestMs) && latestMs >= nowMs) nowMs = latestMs + 1;
+  }
+  return path.join(dir, digitTimestamp(new Date(nowMs)) + ".json");
+};
+var parseDigitTimestamp = (s) => {
+  if (!/^\d{17}$/.test(s)) return NaN;
+  const iso = s.slice(0, 4) + "-" + s.slice(4, 6) + "-" + s.slice(6, 8) + "T" + s.slice(8, 10) + ":" + s.slice(10, 12) + ":" + s.slice(12, 14) + "." + s.slice(14, 17) + "Z";
+  return new Date(iso).getTime();
+};
+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 writePage = (file, items) => {
+  atomicWrite(file, JSON.stringify(items));
+  pageCache.set(file, items);
+};
+var appendToLatestPage = (dir, item) => {
+  ensureLayout();
+  const files = listPageFiles(dir);
+  if (files.length === 0) {
+    writePage(nextPageFilePath(dir), [item]);
+    return;
+  }
+  const latest = files[files.length - 1];
+  const page = loadPage(latest);
+  if (page.length >= PAGE_SIZE) {
+    writePage(nextPageFilePath(dir), [item]);
+  } else {
+    writePage(latest, [...page, item]);
+  }
 };
-var persistIndex = () => {
-  if (!indexCache) return;
-  atomicWrite(INDEX_PATH, JSON.stringify(indexCache, null, 2));
+var updateInPlace = (dir, predicate, mutator) => {
+  const files = listPageFiles(dir).reverse();
+  for (const file of files) {
+    const page = loadPage(file);
+    const i = page.findIndex(predicate);
+    if (i === -1) continue;
+    const next = page.slice();
+    next[i] = mutator(page[i]);
+    writePage(file, next);
+    return true;
+  }
+  return false;
 };
 var loadRunFile = (runId) => {
   const cached = runCache.get(runId);
   if (cached) return cached;
-  const file = safeReadJson(currentRunPath(runId), null);
+  const file = safeReadJson(
+    path.join(RUNS_DIR(), `${runId}.json`),
+    null
+  );
   if (!file) return null;
   runCache.set(runId, file);
   return file;
 };
 var persistRunFile = (runId, file) => {
   runCache.set(runId, file);
-  atomicWrite(path.join(RUNS_DIR, `${runId}.json`), JSON.stringify(file));
+  atomicWrite(path.join(RUNS_DIR(), `${runId}.json`), JSON.stringify(file));
 };
 var stepIsInProgress = (s) => s.duration_ms === null && !s.error;
 var extractFirstMessage = (rawInput) => {
@@ -155,7 +224,6 @@ var recomputeSummary = (file) => {
     id: file.run.id,
     started_at: file.run.started_at,
     function_id: file.run.function_id,
-    metadata: file.run.metadata,
     thread_id: file.run.thread_id,
     step_count: file.steps.length,
     has_error: hasError,
@@ -164,54 +232,57 @@ var recomputeSummary = (file) => {
     type: firstStep?.type ?? null
   };
 };
-var upsertThread = (threadId, runStartedAt) => {
-  const index = loadIndex();
-  const existing = index.threads.find((t) => t.id === threadId);
-  if (existing) {
-    if (new Date(runStartedAt) > new Date(existing.updated_at)) {
-      existing.updated_at = runStartedAt;
-    }
-    existing.run_count += 1;
-  } else {
-    index.threads.push({
-      id: threadId,
-      created_at: runStartedAt,
-      updated_at: runStartedAt,
-      run_count: 1
-    });
-  }
+var upsertThread = (threadId, runStartedAt, metadata) => {
+  const updated = updateInPlace(
+    THREAD_INDEX_DIR(),
+    (t) => t.id === threadId,
+    (existing) => ({
+      ...existing,
+      updated_at: new Date(runStartedAt) > new Date(existing.updated_at) ? runStartedAt : existing.updated_at,
+      run_count: existing.run_count + 1
+    })
+  );
+  if (updated) return;
+  appendToLatestPage(THREAD_INDEX_DIR(), {
+    id: threadId,
+    created_at: runStartedAt,
+    updated_at: runStartedAt,
+    run_count: 1,
+    metadata: metadata && typeof metadata === "object" ? JSON.stringify(metadata) : null
+  });
 };
 var upsertSummary = (file) => {
-  const index = loadIndex();
   const summary = recomputeSummary(file);
-  const i = index.runs.findIndex((r) => r.id === summary.id);
-  if (i === -1) {
-    index.runs.push(summary);
-  } else {
-    index.runs[i] = summary;
-  }
+  const updated = updateInPlace(
+    RUN_INDEX_DIR(),
+    (s) => s.id === summary.id,
+    () => summary
+  );
+  if (updated) return;
+  appendToLatestPage(RUN_INDEX_DIR(), summary);
 };
-var createRun = async (id, functionId, metadata, threadId) => {
+var createRun = async (id, functionId, threadId, metadata) => {
+  await resolveDbDir();
   ensureLayout();
   const existing = loadRunFile(id);
   if (existing) return existing.run;
+  const resolvedThreadId = threadId ?? `auto-${crypto.randomUUID().slice(0, 8)}`;
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const run = {
     id,
     started_at: startedAt,
     function_id: functionId ?? null,
-    metadata: metadata && typeof metadata === "object" ? JSON.stringify(metadata) : null,
-    thread_id: threadId ?? null
+    thread_id: resolvedThreadId
   };
   const file = { version: 1, run, steps: [] };
   persistRunFile(id, file);
   upsertSummary(file);
-  if (threadId) upsertThread(threadId, startedAt);
-  persistIndex();
+  upsertThread(resolvedThreadId, startedAt, metadata);
   notifyServer("run", id);
   return run;
 };
 var createStep = async (step) => {
+  await resolveDbDir();
   ensureLayout();
   const file = loadRunFile(step.run_id);
   if (!file) {
@@ -232,11 +303,11 @@ var createStep = async (step) => {
   file.steps.push(newStep);
   persistRunFile(file.run.id, file);
   upsertSummary(file);
-  persistIndex();
   notifyServer("step", file.run.id);
   return stepNumber;
 };
 var updateStepResult = async (stepId, result) => {
+  await resolveDbDir();
   let file;
   let step;
   for (const cached of runCache.values()) {
@@ -248,15 +319,18 @@ var updateStepResult = async (stepId, result) => {
     }
   }
   if (!file || !step) {
-    for (const summary of loadIndex().runs) {
-      const candidate = loadRunFile(summary.id);
-      if (!candidate) continue;
-      const match = candidate.steps.find((s) => s.id === stepId);
-      if (match) {
-        file = candidate;
-        step = match;
-        break;
+    for (const pageFile of listPageFiles(RUN_INDEX_DIR())) {
+      for (const summary of loadPage(pageFile)) {
+        const candidate = loadRunFile(summary.id);
+        if (!candidate) continue;
+        const match = candidate.steps.find((s) => s.id === stepId);
+        if (match) {
+          file = candidate;
+          step = match;
+          break;
+        }
       }
+      if (file) break;
     }
   }
   if (!file || !step) return;
@@ -281,7 +355,6 @@ var updateStepResult = async (stepId, result) => {
   );
   persistRunFile(file.run.id, file);
   upsertSummary(file);
-  persistIndex();
   notifyServer("step-update", file.run.id);
 };
 
@@ -325,15 +398,15 @@ var aiSdkMiddleware = (options = {}) => {
     );
   }
   registerSignalHandlers();
-  const runId = options.runId ?? generateRunId();
+  const runId = generateRunId();
   let runCreated = false;
   const ensureRunCreated = async () => {
     if (!runCreated) {
       await createRun(
         runId,
         options.functionId,
-        options.metadata,
-        options.threadId
+        options.threadId,
+        options.metadata
       );
       runCreated = true;
     }
@@ -561,12 +634,12 @@ async function createLogger(options = {}) {
       "ailog should not be used in production. Remove createLogger calls from your production builds."
     );
   }
-  const runId = options.runId ?? generateRunId();
+  const runId = generateRunId();
   await createRun(
     runId,
     options.functionId,
-    options.metadata,
-    options.threadId
+    options.threadId,
+    options.metadata
   );
   return {
     id: runId,
@@ -604,6 +677,5 @@ async function createLogger(options = {}) {
 }
 export {
   aiSdkMiddleware,
-  createLogger,
-  generateRunId
+  createLogger
 };

package/dist/viewer/server.js

@@ -12,10 +12,36 @@ import { fileURLToPath } from "url";
 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 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);
@@ -28,23 +54,12 @@ var notifyServerAsync = async (event, runId) => {
       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;
@@ -60,16 +75,12 @@ var ensureGitignore = () => {
 };
 var ensureLayout = () => {
   const isFirstRun = !fs.existsSync(DB_DIR);
-  fs.mkdirSync(RUNS_DIR, { recursive: true });
-  fs.mkdirSync(BLOBS_DIR, { recursive: true });
+  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 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;
@@ -79,7 +90,7 @@ var safeReadJson = (filePath, fallback) => {
   }
 };
 var readBlobIfPresent = (relPath) => {
-  const absolute = path.join(currentDbDir(), relPath);
+  const absolute = path.join(DB_DIR, relPath);
   try {
     if (!fs.existsSync(absolute)) return null;
     return fs.readFileSync(absolute, "utf-8");
@@ -94,38 +105,68 @@ var hydrate = (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 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(currentRunPath(runId), null);
+  const file = safeReadJson(
+    path.join(RUNS_DIR(), `${runId}.json`),
+    null
+  );
   if (!file) return null;
   runCache.set(runId, file);
   return file;
 };
-var reloadDb = async (remoteIndexPath, runId) => {
-  if (remoteIndexPath) {
-    remoteDbDir = path.dirname(remoteIndexPath);
-  }
-  indexCache = null;
+var reloadDb = async (runId) => {
+  pageCache.clear();
   if (runId) {
     runCache.delete(runId);
   } else {
     runCache.clear();
   }
-  loadIndex();
 };
 var hydrateStep = (s) => ({
   ...s,
@@ -134,12 +175,8 @@ var hydrateStep = (s) => ({
   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 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;
@@ -149,14 +186,17 @@ var getRunWithSteps = async (runId) => {
   };
 };
 var clearDatabase = async () => {
+  await resolveDbDir();
   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 });
+  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();
-  indexCache = EMPTY_INDEX();
-  atomicWrite(INDEX_PATH, JSON.stringify(indexCache, null, 2));
+  pageCache.clear();
   notifyServer("clear");
 };
 
@@ -180,17 +220,24 @@ 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());
+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(remoteDbPath);
-  const summaries = await getRunSummaries();
-  const runs = summaries.map((r) => ({
+  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,
-    metadata: r.metadata,
     thread_id: r.thread_id,
     stepCount: r.step_count,
     firstMessage: r.first_message ?? "No user message",
@@ -198,11 +245,11 @@ app.get("/api/runs", async (c) => {
     isInProgress: r.is_in_progress,
     type: r.type ?? void 0
   }));
-  return c.json(runs);
+  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(remoteDbPath, runId);
+  await reloadDb(runId);
   const data = await getRunWithSteps(runId);
   if (!data) {
     return c.json({ error: "Run not found" }, 404);
@@ -213,6 +260,14 @@ app.get("/api/runs/:id", async (c) => {
     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 });
@@ -268,10 +323,7 @@ app.get("/api/events", (c) => {
 });
 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);
+  await reloadDb(body.runId ?? void 0);
   broadcastToClients("update", body);
   return c.json({ success: true });
 });
@@ -328,6 +380,7 @@ var startViewer = (port = 4985) => {
       } else {
         console.log(`\u{1F50D} ailog running at http://localhost:${port}`);
       }
+      console.log(`   Reading .ailog from ${getDbDir()}`);
     }
   );
   server.on("error", (err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ailog/cli",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "CLI to run the ailog LLM logging dashboard",
   "type": "module",
   "private": false,