@kimuson/claude-code-viewer 0.4.7 → 0.4.9

package/dist/main.js

@@ -6,7 +6,7 @@ import { resolve as resolve6 } from "node:path";
 import { NodeContext as NodeContext2 } from "@effect/platform-node";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Effect as Effect42 } from "effect";
+import { Effect as Effect45 } from "effect";
 
 // src/server/core/agent-session/index.ts
 import { Layer as Layer3 } from "effect";
@@ -371,11 +371,12 @@ import { Context as Context3, Effect as Effect3, Layer as Layer4, Ref } from "ef
 import { z as z17 } from "zod";
 var envSchema = z17.object({
   NODE_ENV: z17.enum(["development", "production", "test"]).optional().default("development"),
-  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: z17.string().optional(),
   GLOBAL_CLAUDE_DIR: z17.string().optional(),
   NEXT_PHASE: z17.string().optional(),
   PORT: z17.string().optional().default("3000").transform((val) => parseInt(val, 10)),
-  PATH: z17.string().optional()
+  PATH: z17.string().optional(),
+  CLAUDE_CODE_VIEWER_CC_EXECUTABLE_PATH: z17.string().optional(),
+  CLAUDE_CODE_VIEWER_AUTH_PASSWORD: z17.string().optional()
 });
 
 // src/server/core/platform/services/EnvService.ts
@@ -5149,11 +5150,233 @@ var SchedulerController = class extends Context30.Tag("SchedulerController")() {
   }
 };
 
+// src/server/core/search/presentation/SearchController.ts
+import { Context as Context32, Effect as Effect38, Layer as Layer34 } from "effect";
+
+// src/server/core/search/services/SearchService.ts
+import { FileSystem as FileSystem12, Path as Path15 } from "@effect/platform";
+import { Context as Context31, Effect as Effect37, Layer as Layer33, Ref as Ref11 } from "effect";
+import MiniSearch from "minisearch";
+
+// src/server/core/search/functions/extractSearchableText.ts
+var extractSearchableText = (conversation) => {
+  if (conversation.type === "x-error") {
+    return null;
+  }
+  if (conversation.type === "user") {
+    return extractUserText(conversation);
+  }
+  if (conversation.type === "assistant") {
+    return extractAssistantText(conversation);
+  }
+  return null;
+};
+var extractUserText = (entry) => {
+  const content = entry.message.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((item) => {
+    if (typeof item === "string") return item;
+    if ("text" in item && typeof item.text === "string") return item.text;
+    return "";
+  }).filter(Boolean).join(" ");
+};
+var extractAssistantText = (entry) => {
+  return entry.message.content.filter((item) => {
+    return item.type === "text" && "text" in item;
+  }).map((item) => item.text).join(" ");
+};
+
+// src/server/core/search/services/SearchService.ts
+var INDEX_TTL_MS = 6e4;
+var MAX_TEXT_LENGTH = 2e3;
+var MAX_ASSISTANT_TEXT_LENGTH = 500;
+var createMiniSearchIndex = () => new MiniSearch({
+  fields: ["text"],
+  storeFields: ["id"],
+  searchOptions: {
+    fuzzy: 0.2,
+    prefix: true,
+    boost: { text: 1 }
+  }
+});
+var LayerImpl25 = Effect37.gen(function* () {
+  const fs = yield* FileSystem12.FileSystem;
+  const path = yield* Path15.Path;
+  const context = yield* ApplicationContext;
+  const indexCacheRef = yield* Ref11.make(null);
+  const buildIndex = () => Effect37.gen(function* () {
+    const { claudeProjectsDirPath } = context.claudeCodePaths;
+    const dirExists = yield* fs.exists(claudeProjectsDirPath);
+    if (!dirExists) {
+      return { index: createMiniSearchIndex(), documents: /* @__PURE__ */ new Map() };
+    }
+    const projectEntries = yield* fs.readDirectory(claudeProjectsDirPath);
+    const miniSearch = createMiniSearchIndex();
+    const documentEffects = projectEntries.map(
+      (projectEntry) => Effect37.gen(function* () {
+        const projectPath = path.resolve(claudeProjectsDirPath, projectEntry);
+        const stat = yield* fs.stat(projectPath).pipe(Effect37.catchAll(() => Effect37.succeed(null)));
+        if (stat?.type !== "Directory") {
+          return [];
+        }
+        const projectId = encodeProjectId(projectPath);
+        const projectName = path.basename(projectPath);
+        const sessionEntries = yield* fs.readDirectory(projectPath).pipe(Effect37.catchAll(() => Effect37.succeed([])));
+        const sessionFiles = sessionEntries.filter(isRegularSessionFile);
+        const sessionDocuments = yield* Effect37.all(
+          sessionFiles.map(
+            (sessionFile) => Effect37.gen(function* () {
+              const sessionPath = path.resolve(projectPath, sessionFile);
+              const sessionId = encodeSessionId(sessionPath);
+              const content = yield* fs.readFileString(sessionPath).pipe(Effect37.catchAll(() => Effect37.succeed("")));
+              if (!content) return [];
+              const conversations = parseJsonl(content);
+              const documents = [];
+              for (let i = 0; i < conversations.length; i++) {
+                const conversation = conversations[i];
+                if (conversation === void 0) continue;
+                if (conversation.type !== "user" && conversation.type !== "assistant") {
+                  continue;
+                }
+                let text = extractSearchableText(conversation);
+                if (!text || text.length < 3) continue;
+                const maxLen = conversation.type === "user" ? MAX_TEXT_LENGTH : MAX_ASSISTANT_TEXT_LENGTH;
+                if (text.length > maxLen) {
+                  text = text.slice(0, maxLen);
+                }
+                documents.push({
+                  id: `${sessionId}:${i}`,
+                  projectId,
+                  projectName,
+                  sessionId,
+                  conversationIndex: i,
+                  type: conversation.type,
+                  text,
+                  timestamp: "timestamp" in conversation ? conversation.timestamp : ""
+                });
+              }
+              return documents;
+            })
+          ),
+          { concurrency: 20 }
+        );
+        return sessionDocuments.flat();
+      })
+    );
+    const allDocuments = yield* Effect37.all(documentEffects, {
+      concurrency: 10
+    });
+    const flatDocuments = allDocuments.flat();
+    miniSearch.addAll(flatDocuments);
+    const documentsMap = /* @__PURE__ */ new Map();
+    for (const doc of flatDocuments) {
+      documentsMap.set(doc.id, doc);
+    }
+    return { index: miniSearch, documents: documentsMap };
+  });
+  const getIndex = () => Effect37.gen(function* () {
+    const cached = yield* Ref11.get(indexCacheRef);
+    const now = Date.now();
+    if (cached && now - cached.builtAt < INDEX_TTL_MS) {
+      return { index: cached.index, documents: cached.documents };
+    }
+    const { index, documents } = yield* buildIndex();
+    yield* Ref11.set(indexCacheRef, { index, documents, builtAt: now });
+    return { index, documents };
+  });
+  const search = (query2, limit = 20, projectId) => Effect37.gen(function* () {
+    const { claudeProjectsDirPath } = context.claudeCodePaths;
+    const dirExists = yield* fs.exists(claudeProjectsDirPath);
+    if (!dirExists) {
+      return { results: [] };
+    }
+    const { index: miniSearch, documents } = yield* getIndex();
+    const searchResults = miniSearch.search(query2).slice(0, limit * 2);
+    const results = [];
+    for (const result of searchResults) {
+      if (results.length >= limit) break;
+      const doc = documents.get(String(result.id));
+      if (!doc) continue;
+      if (projectId && doc.projectId !== projectId) continue;
+      const score = doc.type === "user" ? result.score * 1.2 : result.score;
+      const snippetLength = 150;
+      const text = doc.text;
+      const queryLower = query2.toLowerCase();
+      const textLower = text.toLowerCase();
+      const matchIndex = textLower.indexOf(queryLower);
+      let snippet;
+      if (matchIndex !== -1) {
+        const start = Math.max(0, matchIndex - 50);
+        const end = Math.min(text.length, start + snippetLength);
+        snippet = (start > 0 ? "..." : "") + text.slice(start, end) + (end < text.length ? "..." : "");
+      } else {
+        snippet = text.slice(0, snippetLength) + (text.length > snippetLength ? "..." : "");
+      }
+      results.push({
+        projectId: doc.projectId,
+        projectName: doc.projectName,
+        sessionId: doc.sessionId,
+        conversationIndex: doc.conversationIndex,
+        type: doc.type,
+        snippet,
+        timestamp: doc.timestamp,
+        score
+      });
+    }
+    return { results };
+  });
+  const invalidateIndex = () => Ref11.set(indexCacheRef, null);
+  return {
+    search,
+    invalidateIndex
+  };
+});
+var SearchService = class extends Context31.Tag("SearchService")() {
+  static {
+    this.Live = Layer33.effect(this, LayerImpl25);
+  }
+};
+
+// src/server/core/search/presentation/SearchController.ts
+var LayerImpl26 = Effect38.gen(function* () {
+  const searchService = yield* SearchService;
+  const search = (options) => Effect38.gen(function* () {
+    const { query: query2, limit, projectId } = options;
+    if (query2.trim().length < 2) {
+      return {
+        status: 400,
+        response: {
+          error: "Query must contain at least 2 non-whitespace characters"
+        }
+      };
+    }
+    const { results } = yield* searchService.search(
+      query2.trim(),
+      limit,
+      projectId
+    );
+    return {
+      status: 200,
+      response: { results }
+    };
+  });
+  return {
+    search
+  };
+});
+var SearchController = class extends Context32.Tag("SearchController")() {
+  static {
+    this.Live = Layer34.effect(this, LayerImpl26);
+  }
+};
+
 // src/server/core/session/presentation/SessionController.ts
-import { Context as Context31, Effect as Effect38, Layer as Layer33 } from "effect";
+import { Context as Context33, Effect as Effect40, Layer as Layer35 } from "effect";
 
 // src/server/core/session/services/ExportService.ts
-import { Effect as Effect37 } from "effect";
+import { Effect as Effect39 } from "effect";
 var escapeHtml = (text) => {
   const map = {
     "&": "&amp;",
@@ -5412,7 +5635,7 @@ var renderGroupedAssistantEntries = (entries) => {
     </div>
   `;
 };
-var generateSessionHtml = (session, projectId) => Effect37.gen(function* () {
+var generateSessionHtml = (session, projectId) => Effect39.gen(function* () {
   const grouped = groupConsecutiveAssistantMessages(session.conversations);
   const conversationsHtml = grouped.map((group) => {
     if (group.type === "grouped") {
@@ -5932,9 +6155,9 @@ var generateSessionHtml = (session, projectId) => Effect37.gen(function* () {
 });
 
 // src/server/core/session/presentation/SessionController.ts
-var LayerImpl25 = Effect38.gen(function* () {
+var LayerImpl27 = Effect40.gen(function* () {
   const sessionRepository = yield* SessionRepository;
-  const getSession = (options) => Effect38.gen(function* () {
+  const getSession = (options) => Effect40.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -5945,7 +6168,7 @@ var LayerImpl25 = Effect38.gen(function* () {
       response: { session }
     };
   });
-  const exportSessionHtml = (options) => Effect38.gen(function* () {
+  const exportSessionHtml = (options) => Effect40.gen(function* () {
     const { projectId, sessionId } = options;
     const { session } = yield* sessionRepository.getSession(
       projectId,
@@ -5968,9 +6191,9 @@ var LayerImpl25 = Effect38.gen(function* () {
     exportSessionHtml
   };
 });
-var SessionController = class extends Context31.Tag("SessionController")() {
+var SessionController = class extends Context33.Tag("SessionController")() {
   static {
-    this.Live = Layer33.effect(this, LayerImpl25);
+    this.Live = Layer35.effect(this, LayerImpl27);
   }
 };
 
@@ -5979,12 +6202,12 @@ import { Hono } from "hono";
 var honoApp = new Hono();
 
 // src/server/hono/initialize.ts
-import { Context as Context32, Effect as Effect39, Layer as Layer34, Ref as Ref11, Schedule as Schedule2 } from "effect";
-var InitializeService = class extends Context32.Tag("InitializeService")() {
+import { Context as Context34, Effect as Effect41, Layer as Layer36, Ref as Ref12, Schedule as Schedule2 } from "effect";
+var InitializeService = class extends Context34.Tag("InitializeService")() {
   static {
-    this.Live = Layer34.effect(
+    this.Live = Layer36.effect(
       this,
-      Effect39.gen(function* () {
+      Effect41.gen(function* () {
         const eventBus = yield* EventBus;
         const fileWatcher = yield* FileWatcherService;
         const projectRepository = yield* ProjectRepository;
@@ -5992,22 +6215,22 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
         const projectMetaService = yield* ProjectMetaService;
         const sessionMetaService = yield* SessionMetaService;
         const virtualConversationDatabase = yield* VirtualConversationDatabase;
-        const listenersRef = yield* Ref11.make({});
+        const listenersRef = yield* Ref12.make({});
         const startInitialization = () => {
-          return Effect39.gen(function* () {
+          return Effect41.gen(function* () {
             yield* fileWatcher.startWatching();
-            const daemon = Effect39.repeat(
+            const daemon = Effect41.repeat(
               eventBus.emit("heartbeat", {}),
               Schedule2.fixed("10 seconds")
             );
             console.log("start heartbeat");
-            yield* Effect39.forkDaemon(daemon);
+            yield* Effect41.forkDaemon(daemon);
             console.log("after starting heartbeat fork");
             const onSessionChanged = (event) => {
-              Effect39.runFork(
+              Effect41.runFork(
                 projectMetaService.invalidateProject(event.projectId)
               );
-              Effect39.runFork(
+              Effect41.runFork(
                 sessionMetaService.invalidateSession(
                   event.projectId,
                   event.sessionId
@@ -6016,7 +6239,7 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
             };
             const onSessionProcessChanged = (event) => {
               if ((event.changed.type === "completed" || event.changed.type === "paused") && event.changed.sessionId !== void 0) {
-                Effect39.runFork(
+                Effect41.runFork(
                   virtualConversationDatabase.deleteVirtualConversations(
                     event.changed.sessionId
                   )
@@ -6024,18 +6247,18 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
                 return;
               }
             };
-            yield* Ref11.set(listenersRef, {
+            yield* Ref12.set(listenersRef, {
               sessionChanged: onSessionChanged,
               sessionProcessChanged: onSessionProcessChanged
             });
             yield* eventBus.on("sessionChanged", onSessionChanged);
             yield* eventBus.on("sessionProcessChanged", onSessionProcessChanged);
-            yield* Effect39.gen(function* () {
+            yield* Effect41.gen(function* () {
               console.log("Initializing projects cache");
               const { projects } = yield* projectRepository.getProjects();
               console.log(`${projects.length} projects cache initialized`);
               console.log("Initializing sessions cache");
-              const results = yield* Effect39.all(
+              const results = yield* Effect41.all(
                 projects.map(
                   (project) => sessionRepository.getSessions(project.id)
                 ),
@@ -6047,13 +6270,13 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
               );
               console.log(`${totalSessions} sessions cache initialized`);
             }).pipe(
-              Effect39.catchAll(() => Effect39.void),
-              Effect39.withSpan("initialize-cache")
+              Effect41.catchAll(() => Effect41.void),
+              Effect41.withSpan("initialize-cache")
             );
-          }).pipe(Effect39.withSpan("start-initialization"));
+          }).pipe(Effect41.withSpan("start-initialization"));
         };
-        const stopCleanup = () => Effect39.gen(function* () {
-          const listeners = yield* Ref11.get(listenersRef);
+        const stopCleanup = () => Effect41.gen(function* () {
+          const listeners = yield* Ref12.get(listenersRef);
           if (listeners.sessionChanged) {
             yield* eventBus.off("sessionChanged", listeners.sessionChanged);
           }
@@ -6063,7 +6286,7 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
               listeners.sessionProcessChanged
             );
           }
-          yield* Ref11.set(listenersRef, {});
+          yield* Ref12.set(listenersRef, {});
           yield* fileWatcher.stop();
         });
         return {
@@ -6075,10 +6298,62 @@ var InitializeService = class extends Context32.Tag("InitializeService")() {
   }
 };
 
+// src/server/hono/middleware/auth.middleware.ts
+import { Context as Context35, Effect as Effect42, Layer as Layer37 } from "effect";
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
+var generateSessionToken = (password) => {
+  if (!password) return "";
+  return Buffer.from(`ccv-session:${password}`).toString("base64");
+};
+var PUBLIC_API_ROUTES = [
+  "/api/auth/login",
+  "/api/auth/check",
+  "/api/auth/logout",
+  "/api/config",
+  // Allow config access for theme/locale loading
+  "/api/version"
+];
+var LayerImpl28 = Effect42.gen(function* () {
+  const envService = yield* EnvService;
+  const anthPassword = yield* envService.getEnv(
+    "CLAUDE_CODE_VIEWER_AUTH_PASSWORD"
+  ) ?? void 0;
+  const authEnabled = anthPassword !== void 0;
+  const validSessionToken = generateSessionToken(anthPassword);
+  const authMiddleware = createMiddleware(async (c, next) => {
+    if (PUBLIC_API_ROUTES.includes(c.req.path)) {
+      return next();
+    }
+    if (!c.req.path.startsWith("/api")) {
+      return next();
+    }
+    if (!authEnabled) {
+      return next();
+    }
+    const sessionToken = getCookie(c, "ccv-session");
+    if (!sessionToken || sessionToken !== validSessionToken) {
+      return c.json({ error: "Unauthorized" }, 401);
+    }
+    await next();
+  });
+  return {
+    authEnabled,
+    anthPassword,
+    validSessionToken,
+    authMiddleware
+  };
+});
+var AuthMiddleware = class extends Context35.Tag("AuthMiddleware")() {
+  static {
+    this.Live = Layer37.effect(this, LayerImpl28);
+  }
+};
+
 // src/server/hono/route.ts
 import { zValidator } from "@hono/zod-validator";
-import { Effect as Effect41, Runtime as Runtime3 } from "effect";
-import { setCookie as setCookie2 } from "hono/cookie";
+import { Effect as Effect44, Runtime as Runtime3 } from "effect";
+import { deleteCookie, getCookie as getCookie3, setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
 import { z as z28 } from "zod";
@@ -6086,7 +6361,7 @@ import { z as z28 } from "zod";
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.4.7",
+  version: "0.4.9",
   type: "module",
   license: "MIT",
   repository: {
@@ -6123,15 +6398,21 @@ var package_default = {
     e2e: "./scripts/e2e/exec_e2e.sh",
     "e2e:start-server": "./scripts/e2e/start_server.sh",
     "e2e:capture-snapshots": "./scripts/e2e/capture_snapshots.sh",
-    "lingui:extract": "lingui extract --clean",
-    "lingui:compile": "lingui compile --typescript"
+    "lingui:extract": "lingui extract --clean && node ./scripts/lingui-sort.js",
+    "lingui:compile": "lingui compile --typescript",
+    prepare: "lefthook install"
   },
   dependencies: {
     "@anthropic-ai/claude-agent-sdk": "0.1.30",
     "@anthropic-ai/claude-code": "2.0.24",
     "@anthropic-ai/sdk": "0.67.0",
-    "@effect/platform": "0.93.2",
-    "@effect/platform-node": "0.100.0",
+    "@effect/cluster": "0.55.0",
+    "@effect/experimental": "0.57.11",
+    "@effect/platform": "0.93.6",
+    "@effect/platform-node": "0.103.0",
+    "@effect/rpc": "0.72.2",
+    "@effect/sql": "0.48.6",
+    "@effect/workflow": "0.15.1",
     "@hono/node-server": "1.19.5",
     "@hono/zod-validator": "0.7.4",
     "@lingui/core": "5.5.1",
@@ -6141,7 +6422,7 @@ var package_default = {
     "@radix-ui/react-collapsible": "1.1.12",
     "@radix-ui/react-dialog": "1.1.15",
     "@radix-ui/react-hover-card": "1.1.15",
-    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-popover": "1.1.15",
     "@radix-ui/react-select": "2.2.6",
     "@radix-ui/react-slot": "1.2.3",
     "@radix-ui/react-tabs": "1.1.13",
@@ -6154,27 +6435,29 @@ var package_default = {
     "class-variance-authority": "0.7.1",
     clsx: "2.1.1",
     "date-fns": "4.1.0",
-    effect: "3.19.3",
+    effect: "3.19.9",
     "es-toolkit": "1.41.0",
     hono: "4.10.3",
     jotai: "2.15.0",
     "lucide-react": "0.548.0",
+    minisearch: "7.2.0",
     "parse-git-diff": "0.0.19",
     prexit: "2.3.0",
     react: "19.2.0",
     "react-dom": "19.2.0",
     "react-error-boundary": "6.0.0",
-    "react-helmet-async": "^2.0.5",
+    "react-helmet-async": "2.0.5",
     "react-markdown": "10.1.0",
     "react-syntax-highlighter": "15.6.6",
     "remark-gfm": "4.0.1",
     sonner: "2.0.7",
     "tailwind-merge": "3.3.1",
     ulid: "3.0.1",
-    zod: "4.1.12"
+    zod: "4.1.13"
   },
   devDependencies: {
     "@biomejs/biome": "2.3.1",
+    "@effect/language-service": "0.60.0",
     "@lingui/cli": "5.5.1",
     "@lingui/conf": "5.5.1",
     "@lingui/format-json": "5.5.1",
@@ -6190,6 +6473,7 @@ var package_default = {
     "@vitejs/plugin-react-swc": "4.2.0",
     dotenv: "17.2.3",
     esbuild: "0.25.11",
+    lefthook: "2.0.8",
     "npm-run-all2": "8.0.4",
     playwright: "1.56.1",
     "release-it": "19.0.5",
@@ -6351,16 +6635,16 @@ var userConfigSchema = z27.object({
 var defaultUserConfig = userConfigSchema.parse({});
 
 // src/server/lib/effect/toEffectResponse.ts
-import { Effect as Effect40 } from "effect";
+import { Effect as Effect43 } from "effect";
 var effectToResponse = async (ctx, effect) => {
-  const result = await Effect40.runPromise(effect);
+  const result = await Effect43.runPromise(effect);
   const result2 = ctx.json(result.response, result.status);
   return result2;
 };
 
 // src/server/hono/middleware/config.middleware.ts
-import { getCookie, setCookie } from "hono/cookie";
-import { createMiddleware } from "hono/factory";
+import { getCookie as getCookie2, setCookie } from "hono/cookie";
+import { createMiddleware as createMiddleware2 } from "hono/factory";
 
 // src/server/lib/config/parseUserConfig.ts
 var parseUserConfig = (configJson) => {
@@ -6375,9 +6659,9 @@ var parseUserConfig = (configJson) => {
 };
 
 // src/server/hono/middleware/config.middleware.ts
-var configMiddleware = createMiddleware(
+var configMiddleware = createMiddleware2(
   async (c, next) => {
-    const cookie = getCookie(c, "ccv-config");
+    const cookie = getCookie2(c, "ccv-config");
     const parsed = parseUserConfig(cookie);
     if (cookie === void 0) {
       const preferredLocale = detectLocaleFromAcceptLanguage(c.req.header("accept-language")) ?? DEFAULT_LOCALE;
@@ -6396,7 +6680,7 @@ var configMiddleware = createMiddleware(
 );
 
 // src/server/hono/route.ts
-var routes = (app) => Effect41.gen(function* () {
+var routes = (app) => Effect44.gen(function* () {
   const projectController = yield* ProjectController;
   const sessionController = yield* SessionController;
   const agentSessionController = yield* AgentSessionController;
@@ -6408,24 +6692,60 @@ var routes = (app) => Effect41.gen(function* () {
   const claudeCodeController = yield* ClaudeCodeController;
   const schedulerController = yield* SchedulerController;
   const featureFlagController = yield* FeatureFlagController;
+  const searchController = yield* SearchController;
   const envService = yield* EnvService;
   const userConfigService = yield* UserConfigService;
   const claudeCodeLifeCycleService = yield* ClaudeCodeLifeCycleService;
   const initializeService = yield* InitializeService;
-  const runtime = yield* Effect41.runtime();
+  const { authMiddleware, validSessionToken, authEnabled, anthPassword } = yield* AuthMiddleware;
+  const runtime = yield* Effect44.runtime();
   if ((yield* envService.getEnv("NEXT_PHASE")) !== "phase-production-build") {
     yield* initializeService.startInitialization();
     prexit(async () => {
       await Runtime3.runPromise(runtime)(initializeService.stopCleanup());
     });
   }
-  return app.use(configMiddleware).use(async (c, next) => {
-    await Effect41.runPromise(
+  return app.use(configMiddleware).use(authMiddleware).use(async (c, next) => {
+    await Effect44.runPromise(
       userConfigService.setUserConfig({
         ...c.get("userConfig")
       })
     );
     await next();
+  }).post(
+    "/api/auth/login",
+    zValidator("json", z28.object({ password: z28.string() })),
+    async (c) => {
+      const { password } = c.req.valid("json");
+      if (!authEnabled) {
+        return c.json(
+          {
+            error: "Authentication not configured. Set CLAUDE_CODE_VIEWER_AUTH_PASSWORD environment variable."
+          },
+          500
+        );
+      }
+      if (password !== anthPassword) {
+        return c.json({ error: "Invalid password" }, 401);
+      }
+      setCookie2(c, "ccv-session", validSessionToken, {
+        httpOnly: true,
+        secure: false,
+        // Set to true in production with HTTPS
+        sameSite: "Lax",
+        path: "/",
+        maxAge: 60 * 60 * 24 * 7
+        // 7 days
+      });
+      return c.json({ success: true });
+    }
+  ).post("/api/auth/logout", async (c) => {
+    deleteCookie(c, "ccv-session", { path: "/" });
+    return c.json({ success: true });
+  }).get("/api/auth/check", async (c) => {
+    const sessionToken = getCookie3(c, "ccv-session");
+    const isAuthenticated = authEnabled ? sessionToken === validSessionToken : true;
+    return c.json({ authenticated: isAuthenticated, authEnabled });
   }).get("/api/config", async (c) => {
     return c.json({
       config: c.get("userConfig")
@@ -6455,7 +6775,7 @@ var routes = (app) => Effect41.gen(function* () {
         projectController.getProject({
           ...c.req.param(),
           ...c.req.valid("query")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6472,7 +6792,7 @@ var routes = (app) => Effect41.gen(function* () {
         c,
         projectController.createProject({
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6481,13 +6801,13 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       projectController.getProjectLatestSession({
         ...c.req.param()
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/sessions/:sessionId", async (c) => {
     const response = await effectToResponse(
       c,
-      sessionController.getSession({ ...c.req.param() }).pipe(Effect41.provide(runtime))
+      sessionController.getSession({ ...c.req.param() }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get(
@@ -6495,7 +6815,7 @@ var routes = (app) => Effect41.gen(function* () {
     async (c) => {
       const response = await effectToResponse(
         c,
-        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect41.provide(runtime))
+        sessionController.exportSessionHtml({ ...c.req.param() }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6506,7 +6826,7 @@ var routes = (app) => Effect41.gen(function* () {
       agentSessionController.getAgentSession({
         projectId,
         agentId
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/git/current-revisions", async (c) => {
@@ -6514,7 +6834,7 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       gitController.getCurrentRevisions({
         ...c.req.param()
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).post(
@@ -6532,7 +6852,7 @@ var routes = (app) => Effect41.gen(function* () {
         gitController.getGitDiff({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6545,7 +6865,7 @@ var routes = (app) => Effect41.gen(function* () {
         gitController.commitFiles({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6558,7 +6878,7 @@ var routes = (app) => Effect41.gen(function* () {
         gitController.pushCommits({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6571,7 +6891,7 @@ var routes = (app) => Effect41.gen(function* () {
         gitController.commitAndPush({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6580,7 +6900,7 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       claudeCodeController.getClaudeCommands({
         ...c.req.param()
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/projects/:projectId/mcp/list", async (c) => {
@@ -6588,19 +6908,19 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       claudeCodeController.getMcpListRoute({
         ...c.req.param()
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/cc/meta", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getClaudeCodeMeta().pipe(Effect41.provide(runtime))
+      claudeCodeController.getClaudeCodeMeta().pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/cc/features", async (c) => {
     const response = await effectToResponse(
       c,
-      claudeCodeController.getAvailableFeatures().pipe(Effect41.provide(runtime))
+      claudeCodeController.getAvailableFeatures().pipe(Effect44.provide(runtime))
     );
     return response;
   }).get("/api/cc/session-processes", async (c) => {
@@ -6644,7 +6964,7 @@ var routes = (app) => Effect41.gen(function* () {
         claudeCodeSessionProcessController.continueSessionProcess({
           ...c.req.param(),
           ...c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6653,7 +6973,7 @@ var routes = (app) => Effect41.gen(function* () {
     zValidator("json", z28.object({ projectId: z28.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
-      void Effect41.runFork(
+      void Effect44.runFork(
         claudeCodeLifeCycleService.abortTask(sessionProcessId)
       );
       return c.json({ message: "Task aborted" });
@@ -6681,7 +7001,7 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       async (rawStream) => {
         await Runtime3.runPromise(runtime)(
-          sseController.handleSSE(rawStream).pipe(Effect41.provide(TypeSafeSSE.make(rawStream)))
+          sseController.handleSSE(rawStream).pipe(Effect44.provide(TypeSafeSSE.make(rawStream)))
         );
       },
       async (err) => {
@@ -6691,7 +7011,7 @@ var routes = (app) => Effect41.gen(function* () {
   }).get("/api/scheduler/jobs", async (c) => {
     const response = await effectToResponse(
       c,
-      schedulerController.getJobs().pipe(Effect41.provide(runtime))
+      schedulerController.getJobs().pipe(Effect44.provide(runtime))
     );
     return response;
   }).post(
@@ -6702,7 +7022,7 @@ var routes = (app) => Effect41.gen(function* () {
         c,
         schedulerController.addJob({
           job: c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6715,7 +7035,7 @@ var routes = (app) => Effect41.gen(function* () {
         schedulerController.updateJob({
           id: c.req.param("id"),
           job: c.req.valid("json")
-        }).pipe(Effect41.provide(runtime))
+        }).pipe(Effect44.provide(runtime))
       );
       return response;
     }
@@ -6724,7 +7044,7 @@ var routes = (app) => Effect41.gen(function* () {
       c,
       schedulerController.deleteJob({
         id: c.req.param("id")
-      }).pipe(Effect41.provide(runtime))
+      }).pipe(Effect44.provide(runtime))
     );
     return response;
   }).get(
@@ -6763,10 +7083,28 @@ var routes = (app) => Effect41.gen(function* () {
       );
       return response;
     }
+  ).get(
+    "/api/search",
+    zValidator(
+      "query",
+      z28.object({
+        q: z28.string().min(2),
+        limit: z28.string().optional().transform((val) => val ? parseInt(val, 10) : void 0),
+        projectId: z28.string().optional()
+      })
+    ),
+    async (c) => {
+      const { q, limit, projectId } = c.req.valid("query");
+      const response = await effectToResponse(
+        c,
+        searchController.search({ query: q, limit, projectId }).pipe(Effect44.provide(runtime))
+      );
+      return response;
+    }
   ).get("/api/flags", async (c) => {
     const response = await effectToResponse(
       c,
-      featureFlagController.getFlags().pipe(Effect41.provide(runtime))
+      featureFlagController.getFlags().pipe(Effect44.provide(runtime))
     );
     return response;
   });
@@ -6774,13 +7112,13 @@ var routes = (app) => Effect41.gen(function* () {
 
 // src/server/lib/effect/layers.ts
 import { NodeContext } from "@effect/platform-node";
-import { Layer as Layer35 } from "effect";
-var platformLayer = Layer35.mergeAll(
+import { Layer as Layer38 } from "effect";
+var platformLayer = Layer38.mergeAll(
   ApplicationContext.Live,
   UserConfigService.Live,
   EventBus.Live,
   EnvService.Live
-).pipe(Layer35.provide(EnvService.Live), Layer35.provide(NodeContext.layer));
+).pipe(Layer38.provide(EnvService.Live), Layer38.provide(NodeContext.layer));
 
 // src/server/main.ts
 var isDevelopment = process.env.NODE_ENV === "development";
@@ -6803,44 +7141,47 @@ if (!isDevelopment) {
 }
 var program = routes(honoApp).pipe(
   /** Presentation */
-  Effect42.provide(ProjectController.Live),
-  Effect42.provide(SessionController.Live),
-  Effect42.provide(AgentSessionController.Live),
-  Effect42.provide(GitController.Live),
-  Effect42.provide(ClaudeCodeController.Live),
-  Effect42.provide(ClaudeCodeSessionProcessController.Live),
-  Effect42.provide(ClaudeCodePermissionController.Live),
-  Effect42.provide(FileSystemController.Live),
-  Effect42.provide(SSEController.Live),
-  Effect42.provide(SchedulerController.Live),
-  Effect42.provide(FeatureFlagController.Live)
+  Effect45.provide(ProjectController.Live),
+  Effect45.provide(SessionController.Live),
+  Effect45.provide(AgentSessionController.Live),
+  Effect45.provide(GitController.Live),
+  Effect45.provide(ClaudeCodeController.Live),
+  Effect45.provide(ClaudeCodeSessionProcessController.Live),
+  Effect45.provide(ClaudeCodePermissionController.Live),
+  Effect45.provide(FileSystemController.Live),
+  Effect45.provide(SSEController.Live),
+  Effect45.provide(SchedulerController.Live),
+  Effect45.provide(FeatureFlagController.Live),
+  Effect45.provide(SearchController.Live)
 ).pipe(
   /** Application */
-  Effect42.provide(InitializeService.Live),
-  Effect42.provide(FileWatcherService.Live)
+  Effect45.provide(InitializeService.Live),
+  Effect45.provide(FileWatcherService.Live),
+  Effect45.provide(AuthMiddleware.Live)
 ).pipe(
   /** Domain */
-  Effect42.provide(ClaudeCodeLifeCycleService.Live),
-  Effect42.provide(ClaudeCodePermissionService.Live),
-  Effect42.provide(ClaudeCodeSessionProcessService.Live),
-  Effect42.provide(ClaudeCodeService.Live),
-  Effect42.provide(GitService.Live),
-  Effect42.provide(SchedulerService.Live),
-  Effect42.provide(SchedulerConfigBaseDir.Live)
+  Effect45.provide(ClaudeCodeLifeCycleService.Live),
+  Effect45.provide(ClaudeCodePermissionService.Live),
+  Effect45.provide(ClaudeCodeSessionProcessService.Live),
+  Effect45.provide(ClaudeCodeService.Live),
+  Effect45.provide(GitService.Live),
+  Effect45.provide(SchedulerService.Live),
+  Effect45.provide(SchedulerConfigBaseDir.Live),
+  Effect45.provide(SearchService.Live)
 ).pipe(
   /** Infrastructure */
-  Effect42.provide(ProjectRepository.Live),
-  Effect42.provide(SessionRepository.Live),
-  Effect42.provide(ProjectMetaService.Live),
-  Effect42.provide(SessionMetaService.Live),
-  Effect42.provide(VirtualConversationDatabase.Live),
-  Effect42.provide(AgentSessionLayer)
+  Effect45.provide(ProjectRepository.Live),
+  Effect45.provide(SessionRepository.Live),
+  Effect45.provide(ProjectMetaService.Live),
+  Effect45.provide(SessionMetaService.Live),
+  Effect45.provide(VirtualConversationDatabase.Live),
+  Effect45.provide(AgentSessionLayer)
 ).pipe(
   /** Platform */
-  Effect42.provide(platformLayer),
-  Effect42.provide(NodeContext2.layer)
+  Effect45.provide(platformLayer),
+  Effect45.provide(NodeContext2.layer)
 );
-await Effect42.runPromise(program);
+await Effect45.runPromise(program);
 var port = isDevelopment ? (
   // biome-ignore lint/style/noProcessEnv: allow only here
   process.env.DEV_BE_PORT ?? "3401"