@kyleparrott/where-was-i 0.1.0

package/dist/src/web.js

@@ -0,0 +1,512 @@
+import { spawn } from "node:child_process";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import http from "node:http";
+import { mergeEmbeddingConfig } from "./core/config.js";
+import { isEmbeddingProviderConfigured, OpenAICompatibleEmbeddingProvider } from "./core/embeddings.js";
+import { indexCodexSessions } from "./core/indexer.js";
+import { resolveConfiguredSearchMode } from "./core/search-mode.js";
+import { groupSearchResultsBySession, indexStats, listRecentSessions, readMessageContext, readSession, searchSessions } from "./core/search.js";
+import { indexSemanticChunks, semanticFreshness } from "./core/semantic.js";
+import { WEB_CLIENT_SCRIPT } from "./web-client.js";
+import { saveSettings, settingsViewModel } from "./web-settings.js";
+import { renderEmbeddingPanelUpdate, renderHomePage, renderSearchPage, renderSessionPage, renderSettingsPage } from "./web-views.js";
+import { editableConfigPath, parseWebSearchMode, runtimeConfig, sessionHref } from "./web-utils.js";
+const DEFAULT_WEB_PORT = 8765;
+const DEFAULT_WEB_HOST = "127.0.0.1";
+const MAX_BODY_BYTES = 128 * 1024;
+const CONTEXT_BEFORE = 8;
+const CONTEXT_AFTER = 12;
+const SESSION_PREVIEW_LIMIT = 200;
+const SESSION_FULL_LIMIT = 1000;
+export async function startWebServer(options = {}) {
+    const port = options.port ?? DEFAULT_WEB_PORT;
+    const state = {
+        allowedHosts: new Set(),
+        allowedOrigins: new Set(),
+        csrfToken: randomBytes(32).toString("base64url"),
+        embeddingJob: null
+    };
+    const server = http.createServer((request, response) => {
+        void handleRequest(request, response, options, state).catch((error) => {
+            sendError(response, 500, error instanceof Error ? error.message : String(error));
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, DEFAULT_WEB_HOST, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    const url = `http://${DEFAULT_WEB_HOST}:${address.port}/`;
+    for (const host of [`${DEFAULT_WEB_HOST}:${address.port}`, `localhost:${address.port}`]) {
+        state.allowedHosts.add(host);
+        state.allowedOrigins.add(`http://${host}`);
+    }
+    if (options.openBrowser) {
+        openBrowser(url);
+    }
+    return {
+        url,
+        server,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+            server.closeAllConnections();
+        })
+    };
+}
+async function handleRequest(request, response, options, state) {
+    setSecurityHeaders(response);
+    if (!request.url || !request.method) {
+        sendError(response, 400, "Bad request");
+        return;
+    }
+    if (!isAllowedHost(request, state)) {
+        sendError(response, 403, "Forbidden");
+        return;
+    }
+    const url = new URL(request.url, "http://where-was-i.local");
+    if (request.method === "GET") {
+        await handleGet(url, response, options, state);
+        return;
+    }
+    if (request.method === "POST") {
+        if (!isAllowedOrigin(request, state)) {
+            sendError(response, 403, "Forbidden");
+            return;
+        }
+        const body = await readRequestBody(request);
+        if (url.pathname === "/settings") {
+            handleSettingsPost(body, response, options, state);
+            return;
+        }
+        if (url.pathname === "/index") {
+            handleIndexPost(body, response, options, state);
+            return;
+        }
+        if (url.pathname === "/embeddings") {
+            await handleEmbeddingsPost(body, response, options, state);
+            return;
+        }
+        sendError(response, 405, "Method not allowed");
+        return;
+    }
+    sendError(response, 405, "Method not allowed");
+}
+async function handleGet(url, response, options, state) {
+    if (url.pathname === "/favicon.ico") {
+        response.writeHead(204);
+        response.end();
+        return;
+    }
+    if (url.pathname === "/app.js") {
+        sendJavaScript(response, WEB_CLIENT_SCRIPT);
+        return;
+    }
+    if (url.pathname === "/health") {
+        sendJson(response, { ok: true });
+        return;
+    }
+    if (url.pathname === "/") {
+        await sendHome(response, options, state, homeFlashFromParams(url.searchParams), embeddingJobForHome(state, url.searchParams.get("embeddingJob")));
+        return;
+    }
+    if (url.pathname === "/search") {
+        await sendSearch(response, options, url.searchParams);
+        return;
+    }
+    if (url.pathname.startsWith("/embedding-jobs/")) {
+        await sendEmbeddingJob(response, options, state, url);
+        return;
+    }
+    if (url.pathname.startsWith("/sessions/")) {
+        sendSessionDetail(response, options, url);
+        return;
+    }
+    if (url.pathname === "/settings") {
+        sendSettings(response, options, state, {
+            saved: url.searchParams.get("saved") === "1"
+        });
+        return;
+    }
+    sendError(response, 404, "Not found");
+}
+async function sendHome(response, options, state, flash = null, embeddingJob = null) {
+    const config = runtimeConfig(options);
+    const status = await statusSnapshot(config);
+    sendHtml(response, renderHomePage(status, listRecentSessions(config.dbPath, 30), state.csrfToken, flash, embeddingJob));
+}
+async function sendSearch(response, options, params) {
+    const query = (params.get("q") ?? "").trim();
+    const requestedMode = parseWebSearchMode(params.get("mode") ?? "auto");
+    const config = runtimeConfig(options);
+    const state = query ? await searchForPage(config, query, requestedMode) : null;
+    sendHtml(response, renderSearchPage(query, requestedMode, state));
+}
+async function sendEmbeddingJob(response, options, state, url) {
+    const jobId = decodeURIComponent(url.pathname.slice("/embedding-jobs/".length));
+    if (!jobId) {
+        sendError(response, 404, "Embedding job not found");
+        return;
+    }
+    const job = embeddingJobForHome(state, jobId);
+    const config = runtimeConfig(options);
+    if (!job) {
+        sendJson(response, renderEmbeddingPanelUpdate(await statusSnapshot(config), null));
+        return;
+    }
+    const status = await statusSnapshot(config);
+    sendJson(response, renderEmbeddingPanelUpdate(status, job));
+}
+function sendSessionDetail(response, options, url) {
+    const sessionId = decodeURIComponent(url.pathname.slice("/sessions/".length));
+    if (!sessionId) {
+        sendError(response, 404, "Session not found");
+        return;
+    }
+    const config = runtimeConfig(options);
+    const selectedMessageId = url.searchParams.get("messageId");
+    const query = url.searchParams.get("q") ?? "";
+    const mode = parseWebSearchMode(url.searchParams.get("mode") ?? "auto");
+    const full = url.searchParams.get("full") === "1";
+    const detail = sessionMessagesForDetail(config, sessionId, selectedMessageId, full);
+    if (detail.messages.length === 0) {
+        sendError(response, 404, "Session not found");
+        return;
+    }
+    const firstMessage = detail.messages[0];
+    const referenceMessage = detail.selectedMessage ?? firstMessage;
+    const fullHref = selectedMessageId && !full && detail.selectedMessage
+        ? sessionHref(sessionId, selectedMessageId, query, mode, true)
+        : null;
+    sendHtml(response, renderSessionPage({
+        sessionId,
+        messages: detail.messages,
+        selectedMessageId: detail.selectedMessage?.id ?? selectedMessageId,
+        query,
+        mode,
+        codexUrl: `codex://threads/${encodeURIComponent(referenceMessage.conversationId)}`,
+        sourcePath: referenceMessage.sourcePath,
+        backHref: query ? `/search?q=${encodeURIComponent(query)}&mode=${encodeURIComponent(mode)}` : "/",
+        contextNotice: detail.contextNotice,
+        fullHref
+    }));
+}
+function sendSettings(response, options, state, extra = {}) {
+    const model = {
+        ...settingsViewModel(editableConfigPath(options), extra.saved ?? false),
+        ...extra
+    };
+    sendHtml(response, renderSettingsPage(model, state.csrfToken));
+}
+function handleSettingsPost(body, response, options, state) {
+    const params = new URLSearchParams(body);
+    if (!isValidToken(params.get("settingsToken"), state.csrfToken)) {
+        sendError(response, 403, "Forbidden");
+        return;
+    }
+    const result = saveSettings(editableConfigPath(options), params);
+    if (result.errors.length > 0) {
+        sendSettings(response, options, state, {
+            values: result.values,
+            errors: result.errors,
+            saved: false
+        });
+        return;
+    }
+    response.writeHead(303, { location: "/settings?saved=1" });
+    response.end();
+}
+function handleIndexPost(body, response, options, state) {
+    const params = new URLSearchParams(body);
+    if (!isValidToken(params.get("actionToken"), state.csrfToken)) {
+        sendError(response, 403, "Forbidden");
+        return;
+    }
+    const config = runtimeConfig(options);
+    const summary = indexCodexSessions({
+        dbPath: config.dbPath,
+        codexHome: config.codexHome
+    });
+    redirectHome(response, {
+        action: "index",
+        indexed: String(summary.indexed),
+        skipped: String(summary.skipped),
+        failed: String(summary.failed.length)
+    });
+}
+async function handleEmbeddingsPost(body, response, options, state) {
+    const params = new URLSearchParams(body);
+    if (!isValidToken(params.get("actionToken"), state.csrfToken)) {
+        sendError(response, 403, "Forbidden");
+        return;
+    }
+    const config = runtimeConfig(options);
+    const embedding = mergeEmbeddingConfig(config);
+    const provider = new OpenAICompatibleEmbeddingProvider(embedding);
+    if (!isEmbeddingProviderConfigured(provider.config)) {
+        redirectHome(response, {
+            action: "embeddings",
+            available: "0",
+            failed: "Configure embeddings before indexing semantic vectors."
+        });
+        return;
+    }
+    if (state.embeddingJob?.status === "running") {
+        redirectHome(response, {
+            embeddingJob: state.embeddingJob.id
+        });
+        return;
+    }
+    const job = {
+        id: randomBytes(12).toString("base64url"),
+        status: "running",
+        startedAt: new Date().toISOString(),
+        completedAt: null,
+        progress: null,
+        summary: null,
+        error: null
+    };
+    state.embeddingJob = job;
+    void runEmbeddingJob(job, config);
+    redirectHome(response, {
+        embeddingJob: job.id
+    });
+}
+async function runEmbeddingJob(job, config) {
+    try {
+        const summary = await indexSemanticChunks({
+            dbPath: config.dbPath,
+            embedding: mergeEmbeddingConfig(config),
+            maxChunks: config.semantic.startupMaxChunks ?? undefined,
+            onProgress: (progress) => {
+                job.progress = progress;
+            }
+        });
+        job.summary = summary;
+        job.status = summary.available ? "complete" : "failed";
+        job.error = summary.failed;
+    }
+    catch (error) {
+        job.status = "failed";
+        job.error = error instanceof Error ? error.message : String(error);
+    }
+    finally {
+        job.completedAt = new Date().toISOString();
+    }
+}
+function isAllowedHost(request, state) {
+    const host = request.headers.host?.toLowerCase();
+    return Boolean(host && state.allowedHosts.has(host));
+}
+function isAllowedOrigin(request, state) {
+    const origin = request.headers.origin;
+    return typeof origin !== "string" || state.allowedOrigins.has(origin);
+}
+function isValidToken(submitted, expected) {
+    if (!submitted || submitted.length !== expected.length) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(submitted), Buffer.from(expected));
+}
+function redirectHome(response, params) {
+    const search = new URLSearchParams(params);
+    response.writeHead(303, { location: `/?${search.toString()}` });
+    response.end();
+}
+function homeFlashFromParams(params) {
+    const action = params.get("action");
+    if (action === "index") {
+        const indexed = params.get("indexed") ?? "0";
+        const skipped = params.get("skipped") ?? "0";
+        const failed = params.get("failed") ?? "0";
+        return {
+            kind: failed === "0" ? "success" : "alert",
+            message: `Index complete: ${indexed} indexed, ${skipped} skipped, ${failed} failed.`
+        };
+    }
+    if (action === "embeddings") {
+        const failed = params.get("failed") ?? "";
+        if (params.get("available") === "0") {
+            return {
+                kind: "alert",
+                message: failed || "Embedding provider is unavailable."
+            };
+        }
+        const indexed = params.get("indexed") ?? "0";
+        return {
+            kind: "success",
+            message: indexed === "0" ? "Embeddings are already up to date." : `Embedded ${indexed} chunk${indexed === "1" ? "" : "s"}.`
+        };
+    }
+    return null;
+}
+function embeddingJobForHome(state, requestedId) {
+    const job = state.embeddingJob;
+    if (!job) {
+        return null;
+    }
+    if (requestedId !== job.id) {
+        return null;
+    }
+    const progress = job.progress;
+    return {
+        id: job.id,
+        status: job.status,
+        startedAt: job.startedAt,
+        completedAt: job.completedAt,
+        phase: progress?.phase ?? null,
+        providerId: progress?.providerId ?? job.summary?.providerId ?? null,
+        model: progress?.model ?? job.summary?.model ?? null,
+        indexed: progress?.indexed ?? job.summary?.indexed ?? 0,
+        total: progress?.total ?? null,
+        failed: job.error ?? job.summary?.failed ?? progress?.failed ?? null
+    };
+}
+function sessionMessagesForDetail(config, sessionId, messageId, full) {
+    if (messageId && !full) {
+        const context = readMessageContext(config.dbPath, messageId, CONTEXT_BEFORE, CONTEXT_AFTER);
+        if (context.target?.sessionId === sessionId) {
+            return {
+                messages: [...context.before, context.target, ...context.after],
+                selectedMessage: context.target,
+                contextNotice: `Showing ${context.before.length} messages before and ${context.after.length} after the selected hit.`
+            };
+        }
+    }
+    const limit = full ? SESSION_FULL_LIMIT : SESSION_PREVIEW_LIMIT;
+    const messages = readSession(config.dbPath, sessionId, limit);
+    return {
+        messages,
+        selectedMessage: messages.find((message) => message.id === messageId) ?? null,
+        contextNotice: !full && messages.length === SESSION_PREVIEW_LIMIT
+            ? `Showing the first ${SESSION_PREVIEW_LIMIT} messages. Open from a search hit for focused context.`
+            : null
+    };
+}
+async function searchForPage(config, query, requestedMode) {
+    const embedding = mergeEmbeddingConfig(config);
+    const provider = new OpenAICompatibleEmbeddingProvider(embedding);
+    const semanticConfigured = isEmbeddingProviderConfigured(provider.config);
+    const selectedMode = await resolveConfiguredSearchMode({
+        dbPath: config.dbPath,
+        requestedMode,
+        embedding
+    });
+    try {
+        const results = await searchSessions({
+            dbPath: config.dbPath,
+            query,
+            limit: 25,
+            mode: selectedMode,
+            embedding
+        });
+        return {
+            requestedMode,
+            selectedMode,
+            warning: requestedMode === "auto" && selectedMode === "fts" && semanticConfigured
+                ? "Semantic search is not ready, so full-text search was used."
+                : null,
+            groups: groupSearchResultsBySession(results, 4)
+        };
+    }
+    catch (error) {
+        if (selectedMode === "fts") {
+            throw error;
+        }
+        const results = await searchSessions({
+            dbPath: config.dbPath,
+            query,
+            limit: 25,
+            mode: "fts"
+        });
+        return {
+            requestedMode,
+            selectedMode: "fts",
+            warning: `Semantic search failed, so full-text search was used. ${error instanceof Error ? error.message : String(error)}`,
+            groups: groupSearchResultsBySession(results, 4)
+        };
+    }
+}
+async function statusSnapshot(config) {
+    const stats = indexStats(config.dbPath);
+    const embedding = mergeEmbeddingConfig(config);
+    const provider = new OpenAICompatibleEmbeddingProvider(embedding);
+    const semanticConfigured = isEmbeddingProviderConfigured(provider.config);
+    const semantic = await semanticFreshness({
+        dbPath: config.dbPath,
+        embedding,
+        probeProvider: false
+    });
+    return {
+        index: stats,
+        semanticConfigured,
+        semanticIndexedChunks: semantic.indexedChunks,
+        semanticTotalEligibleChunks: semantic.totalEligibleChunks,
+        semanticMissingChunks: semantic.missingChunks,
+        semanticLastIndexedAt: semantic.lastIndexedAt,
+        semanticIncompatibleStoredVectors: semantic.incompatibleStoredVectors,
+        recommendedMode: semanticConfigured && semantic.indexedChunks > 0 && semantic.incompatibleStoredVectors === 0 ? "hybrid" : "fts"
+    };
+}
+function sendHtml(response, html) {
+    response.writeHead(200, {
+        "content-type": "text/html; charset=utf-8",
+        "cache-control": "no-store"
+    });
+    response.end(html);
+}
+function sendJson(response, value) {
+    response.writeHead(200, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store"
+    });
+    response.end(JSON.stringify(value));
+}
+function sendJavaScript(response, source) {
+    response.writeHead(200, {
+        "content-type": "text/javascript; charset=utf-8",
+        "cache-control": "no-store"
+    });
+    response.end(source);
+}
+function sendError(response, status, message) {
+    response.writeHead(status, {
+        "content-type": "text/plain; charset=utf-8",
+        "cache-control": "no-store"
+    });
+    response.end(message);
+}
+function setSecurityHeaders(response) {
+    response.setHeader("x-content-type-options", "nosniff");
+    response.setHeader("referrer-policy", "same-origin");
+    response.setHeader("cross-origin-resource-policy", "same-origin");
+    response.setHeader("content-security-policy", "default-src 'none'; script-src 'self'; connect-src 'self'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'");
+}
+function readRequestBody(request) {
+    return new Promise((resolve, reject) => {
+        let total = 0;
+        const chunks = [];
+        request.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > MAX_BODY_BYTES) {
+                reject(new Error("Request body too large."));
+                request.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        request.on("error", reject);
+    });
+}
+function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@kyleparrott/where-was-i",
+  "version": "0.1.0",
+  "private": false,
+  "license": "Apache-2.0",
+  "author": "Kyle Parrott",
+  "type": "module",
+  "description": "Local-first CLI and MCP server for finding coding-agent sessions you almost remember.",
+  "homepage": "https://github.com/kyleparrott/where-was-i#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kyleparrott/where-was-i.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kyleparrott/where-was-i/issues"
+  },
+  "keywords": [
+    "codex",
+    "mcp",
+    "search",
+    "sqlite",
+    "fts",
+    "embeddings",
+    "where-was-i",
+    "wwi"
+  ],
+  "bin": {
+    "where-was-i": "dist/src/cli.js",
+    "wwi": "dist/src/cli.js",
+    "where-was-i-mcp": "dist/src/mcp.js"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run clean && npm run build && node --test dist/tests/*.test.js",
+    "cli": "npm run build && node dist/src/cli.js",
+    "prepack": "npm run clean && npm run build"
+  },
+  "files": [
+    "dist/src",
+    "docs/assets",
+    "README.md",
+    "LICENSE"
+  ],
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.9.0",
+    "commander": "^14.0.3",
+    "sqlite-vec": "^0.1.9",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.0",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}