veryfront 0.0.81 → 0.0.83

package/esm/src/cache/multi-tier.js

@@ -0,0 +1,326 @@
+/**
+ * Multi-Tier Cache Abstraction
+ *
+ * Generic implementation for L1 → L2 → L3 cache flows with automatic backfill.
+ * This provides consistent caching behavior across the codebase:
+ *
+ * - L1: In-memory (fastest, per-pod, lost on restart)
+ * - L2: Local disk (fast, per-pod, survives restart)
+ * - L3: Distributed (Redis/API, cross-pod, shared state)
+ *
+ * When a cache hit occurs at a lower tier (e.g., L3), the value is automatically
+ * backfilled to higher tiers (L1, L2) for faster subsequent access.
+ *
+ * @module cache/multi-tier
+ */
+import { rendererLogger as logger } from "../utils/index.js";
+import { withSpan } from "../observability/tracing/otlp-setup.js";
+import { SpanNames } from "../observability/tracing/span-names.js";
+/**
+ * Multi-tier cache implementation.
+ *
+ * Provides automatic fallthrough from L1 → L2 → L3 with backfill on hits.
+ *
+ * @example
+ * ```typescript
+ * const cache = new MultiTierCache({
+ *   name: "http-module",
+ *   l1: new MemoryTier(),
+ *   l3: await CacheBackends.httpModule(),
+ *   defaultTtlSeconds: 86400,
+ * });
+ *
+ * const value = await cache.get("my-key");
+ * // If found in L3, automatically backfills L1
+ * ```
+ */
+export class MultiTierCache {
+    config;
+    stats = {
+        gets: 0,
+        l1Hits: 0,
+        l2Hits: 0,
+        l3Hits: 0,
+        misses: 0,
+        sets: 0,
+        backfills: 0,
+    };
+    constructor(config) {
+        this.config = {
+            defaultTtlSeconds: 300,
+            backfillOnHit: true,
+            asyncBackfill: true,
+            ...config,
+        };
+    }
+    /**
+     * Get a value from the cache.
+     *
+     * Checks tiers in order: L1 → L2 → L3.
+     * On hit at a lower tier, backfills higher tiers.
+     */
+    get(key) {
+        return withSpan(SpanNames.CACHE_MULTI_TIER_GET, async (span) => {
+            this.stats.gets++;
+            span?.setAttribute("cache.name", this.config.name);
+            span?.setAttribute("cache.key", key);
+            // L1: Memory
+            if (this.config.l1) {
+                try {
+                    const value = await this.config.l1.get(key);
+                    if (value !== null) {
+                        this.stats.l1Hits++;
+                        span?.setAttribute("cache.hit_tier", "l1");
+                        logger.debug(`[${this.config.name}] L1 hit`, { key });
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L1 get error`, { key, error });
+                }
+            }
+            // L2: Disk
+            if (this.config.l2) {
+                try {
+                    const value = await this.config.l2.get(key);
+                    if (value !== null) {
+                        this.stats.l2Hits++;
+                        span?.setAttribute("cache.hit_tier", "l2");
+                        logger.debug(`[${this.config.name}] L2 hit`, { key });
+                        const backfillPromise = this.backfill(key, value, ["l1"]);
+                        if (this.config.asyncBackfill) {
+                            void backfillPromise;
+                        }
+                        else {
+                            await backfillPromise;
+                        }
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L2 get error`, { key, error });
+                }
+            }
+            // L3: Distributed
+            if (this.config.l3) {
+                try {
+                    const value = await this.config.l3.get(key);
+                    if (value !== null) {
+                        this.stats.l3Hits++;
+                        span?.setAttribute("cache.hit_tier", "l3");
+                        logger.debug(`[${this.config.name}] L3 hit`, { key });
+                        const backfillPromise = this.backfill(key, value, ["l1", "l2"]);
+                        if (this.config.asyncBackfill) {
+                            void backfillPromise;
+                        }
+                        else {
+                            await backfillPromise;
+                        }
+                        return value;
+                    }
+                }
+                catch (error) {
+                    logger.debug(`[${this.config.name}] L3 get error`, { key, error });
+                }
+            }
+            this.stats.misses++;
+            span?.setAttribute("cache.hit_tier", "miss");
+            return null;
+        }, { "cache.operation": "get" });
+    }
+    /**
+     * Set a value in all tiers.
+     *
+     * Writes to all configured tiers in parallel (or sequentially if asyncBackfill=false).
+     */
+    set(key, value, ttlSeconds) {
+        return withSpan(SpanNames.CACHE_MULTI_TIER_SET, (span) => {
+            this.stats.sets++;
+            const ttl = ttlSeconds ?? this.config.defaultTtlSeconds;
+            span?.setAttribute("cache.name", this.config.name);
+            span?.setAttribute("cache.key", key);
+            span?.setAttribute("cache.ttl_seconds", ttl);
+            const tiers = [this.config.l1, this.config.l2, this.config.l3].filter((t) => t !== undefined);
+            const setOps = tiers.map((tier) => tier.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] Set error in ${tier.name}`, { key, error });
+            }));
+            if (this.config.asyncBackfill) {
+                // Fire-and-forget for performance (don't await)
+                void Promise.all(setOps);
+                return Promise.resolve();
+            }
+            // Wait for all tiers
+            return Promise.all(setOps).then(() => { });
+        }, { "cache.operation": "set" });
+    }
+    /**
+     * Delete a value from all tiers.
+     */
+    async delete(key) {
+        const tiers = [this.config.l1, this.config.l2, this.config.l3].filter((t) => t !== undefined && t.delete !== undefined);
+        await Promise.all(tiers.map((tier) => tier.delete?.(key).catch((error) => {
+            logger.debug(`[${this.config.name}] Delete error in ${tier.name}`, { key, error });
+        })));
+    }
+    /**
+     * Get or compute a value.
+     *
+     * If the key exists in any tier, returns it.
+     * Otherwise, calls the compute function and stores the result in all tiers.
+     */
+    async getOrCompute(key, computeFn, ttlSeconds) {
+        const cached = await this.get(key);
+        if (cached !== null)
+            return cached;
+        const value = await computeFn();
+        await this.set(key, value, ttlSeconds);
+        return value;
+    }
+    /**
+     * Batch get multiple values.
+     *
+     * Uses batch operations where available for efficiency.
+     * Returns a map of key → value (null if not found).
+     */
+    async getBatch(keys) {
+        if (keys.length === 0)
+            return new Map();
+        const results = new Map();
+        let remainingKeys = [...keys];
+        const backfillPromises = [];
+        // Check L1
+        if (this.config.l1 && remainingKeys.length > 0) {
+            try {
+                const l1Results = this.config.l1.getBatch
+                    ? await this.config.l1.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l1, remainingKeys);
+                for (const [key, value] of l1Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l1Hits++;
+                    }
+                }
+                remainingKeys = remainingKeys.filter((k) => !results.has(k) || results.get(k) === null);
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L1 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Check L2
+        if (this.config.l2 && remainingKeys.length > 0) {
+            try {
+                const l2Results = this.config.l2.getBatch
+                    ? await this.config.l2.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l2, remainingKeys);
+                for (const [key, value] of l2Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l2Hits++;
+                        backfillPromises.push(this.backfill(key, value, ["l1"]));
+                    }
+                }
+                remainingKeys = remainingKeys.filter((k) => !results.has(k) || results.get(k) === null);
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L2 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Check L3
+        if (this.config.l3 && remainingKeys.length > 0) {
+            try {
+                const l3Results = this.config.l3.getBatch
+                    ? await this.config.l3.getBatch(remainingKeys)
+                    : await this.individualGets(this.config.l3, remainingKeys);
+                for (const [key, value] of l3Results) {
+                    if (value !== null) {
+                        results.set(key, value);
+                        this.stats.l3Hits++;
+                        backfillPromises.push(this.backfill(key, value, ["l1", "l2"]));
+                    }
+                    else {
+                        results.set(key, null);
+                        this.stats.misses++;
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug(`[${this.config.name}] L3 getBatch error`, {
+                    keyCount: remainingKeys.length,
+                    error,
+                });
+            }
+        }
+        // Mark remaining as misses
+        for (const key of remainingKeys) {
+            if (!results.has(key)) {
+                results.set(key, null);
+                this.stats.misses++;
+            }
+        }
+        if (backfillPromises.length > 0) {
+            if (this.config.asyncBackfill) {
+                void Promise.all(backfillPromises);
+            }
+            else {
+                await Promise.all(backfillPromises);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get cache statistics.
+     */
+    getStats() {
+        const totalHits = this.stats.l1Hits + this.stats.l2Hits + this.stats.l3Hits;
+        const hitRate = this.stats.gets > 0 ? totalHits / this.stats.gets : 0;
+        return { ...this.stats, hitRate };
+    }
+    /**
+     * Reset statistics.
+     */
+    resetStats() {
+        this.stats = {
+            gets: 0,
+            l1Hits: 0,
+            l2Hits: 0,
+            l3Hits: 0,
+            misses: 0,
+            sets: 0,
+            backfills: 0,
+        };
+    }
+    /**
+     * Backfill higher tiers with a value found at a lower tier.
+     */
+    backfill(key, value, tiers) {
+        if (!this.config.backfillOnHit)
+            return Promise.resolve();
+        this.stats.backfills++;
+        const ttl = this.config.defaultTtlSeconds;
+        const backfillOps = [];
+        if (tiers.includes("l1") && this.config.l1) {
+            backfillOps.push(this.config.l1.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] L1 backfill error`, { key, error });
+            }));
+        }
+        if (tiers.includes("l2") && this.config.l2) {
+            backfillOps.push(this.config.l2.set(key, value, ttl).catch((error) => {
+                logger.debug(`[${this.config.name}] L2 backfill error`, { key, error });
+            }));
+        }
+        return Promise.all(backfillOps).then(() => { });
+    }
+    /**
+     * Helper for individual gets when batch operation is not available.
+     */
+    async individualGets(tier, keys) {
+        const results = await Promise.all(keys.map(async (key) => [key, await tier.get(key)]));
+        return new Map(results);
+    }
+}

package/esm/src/cli/app/actions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CLI App Actions
+ *
+ * Handlers for opening projects in browser, Studio, and IDE.
+ * Uses cross-runtime platform abstractions for filesystem and command execution.
+ */
+import type { ProjectInfo } from "./state.js";
+import { type RuntimeEnv } from "../../config/runtime-env.js";
+export type IDE = "cursor" | "code" | "zed" | "idea" | "webstorm";
+export interface ActionResult {
+    success: boolean;
+    message?: string;
+}
+export declare function openInBrowser(project: ProjectInfo, port: number): Promise<ActionResult>;
+export declare function openInStudio(project: ProjectInfo): Promise<ActionResult>;
+export declare function detectIDEs(): Promise<IDE[]>;
+export declare function getPreferredIDE(): Promise<IDE | null>;
+export declare function openInIDE(project: ProjectInfo, ide?: IDE): Promise<ActionResult>;
+export declare function openFileInIDE(filePath: string, ide?: IDE): Promise<ActionResult>;
+export declare function clearProjectCache(project: ProjectInfo): Promise<ActionResult>;
+export declare function openMCPSettings(env?: RuntimeEnv): Promise<ActionResult>;
+export declare function quickOpen(projects: Array<{
+    slug: string;
+    path: string;
+}>, num: number, port: number): Promise<ActionResult>;
+//# sourceMappingURL=actions.d.ts.map

package/esm/src/cli/app/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../src/src/cli/app/actions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE7E,MAAM,MAAM,GAAG,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,UAAU,CAAC;AAElE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAiDD,wBAAsB,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAS7F;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAS9E;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAUjD;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CAG3D;AAsBD,wBAAsB,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CAMtF;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,CAAC,CAEhF;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAgBnF;AAED,wBAAsB,eAAe,CAAC,GAAG,GAAE,UAA4B,GAAG,OAAO,CAAC,YAAY,CAAC,CAkB9F;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAC/C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,YAAY,CAAC,CAQvB"}

package/esm/src/cli/app/actions.js

@@ -0,0 +1,152 @@
+/**
+ * CLI App Actions
+ *
+ * Handlers for opening projects in browser, Studio, and IDE.
+ * Uses cross-runtime platform abstractions for filesystem and command execution.
+ */
+import { openBrowser } from "../auth/browser.js";
+import { createFileSystem } from "../../platform/compat/fs.js";
+import { getOsType, runCommand } from "../../platform/compat/process.js";
+import { join } from "../../platform/compat/path/index.js";
+import { getRuntimeEnv } from "../../config/runtime-env.js";
+/** IDE command-line executables */
+const IDE_COMMANDS = {
+    cursor: "cursor",
+    code: "code",
+    zed: "zed",
+    idea: "idea",
+    webstorm: "webstorm",
+};
+/** IDE display names */
+const IDE_NAMES = {
+    cursor: "Cursor",
+    code: "VS Code",
+    zed: "Zed",
+    idea: "IntelliJ IDEA",
+    webstorm: "WebStorm",
+};
+/** IDE detection order (preferred first) */
+const IDE_DETECTION_ORDER = ["cursor", "code", "zed", "idea", "webstorm"];
+/** Cache directories to clear relative to project path */
+const PROJECT_CACHE_DIRS = [".cache", "node_modules/.cache"];
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function commandExists(cmd) {
+    try {
+        const whichCmd = getOsType() === "windows" ? "where" : "which";
+        const result = await runCommand(whichCmd, { args: [cmd] });
+        return result.success;
+    }
+    catch {
+        return false;
+    }
+}
+async function runCommandLocal(cmd, args) {
+    try {
+        const result = await runCommand(cmd, { args });
+        return result.success;
+    }
+    catch {
+        return false;
+    }
+}
+export async function openInBrowser(project, port) {
+    const url = `http://${project.slug}.veryfront.me:${port}`;
+    try {
+        await openBrowser(url);
+        return { success: true, message: `Opened ${url}` };
+    }
+    catch (error) {
+        return { success: false, message: `Failed to open browser: ${formatError(error)}` };
+    }
+}
+export async function openInStudio(project) {
+    const url = `https://veryfront.com/projects/${project.slug}`;
+    try {
+        await openBrowser(url);
+        return { success: true, message: `Opened Studio for ${project.slug}` };
+    }
+    catch (error) {
+        return { success: false, message: `Failed to open Studio: ${formatError(error)}` };
+    }
+}
+export async function detectIDEs() {
+    const available = [];
+    for (const ide of IDE_DETECTION_ORDER) {
+        if (await commandExists(IDE_COMMANDS[ide])) {
+            available.push(ide);
+        }
+    }
+    return available;
+}
+export async function getPreferredIDE() {
+    const ides = await detectIDEs();
+    return ides[0] ?? null;
+}
+async function openPathInIDE(path, ide) {
+    const targetIDE = ide ?? (await getPreferredIDE());
+    if (!targetIDE) {
+        return {
+            success: false,
+            message: "No supported IDE found. Install VS Code, Cursor, or Zed.",
+        };
+    }
+    const cmd = IDE_COMMANDS[targetIDE];
+    const name = IDE_NAMES[targetIDE];
+    if (await runCommandLocal(cmd, [path])) {
+        return { success: true, message: `Opened in ${name}` };
+    }
+    return { success: false, message: `Failed to open ${name}` };
+}
+export async function openInIDE(project, ide) {
+    const result = await openPathInIDE(project.path, ide);
+    if (!result.success)
+        return result;
+    const ideName = result.message?.split(" in ")[1];
+    return { success: true, message: `Opened ${project.slug} in ${ideName}` };
+}
+export function openFileInIDE(filePath, ide) {
+    return openPathInIDE(filePath, ide);
+}
+export async function clearProjectCache(project) {
+    const fs = createFileSystem();
+    let cleared = 0;
+    for (const relativeDir of PROJECT_CACHE_DIRS) {
+        const dir = join(project.path, relativeDir);
+        try {
+            await fs.remove(dir, { recursive: true });
+            cleared++;
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    const message = cleared > 0 ? `Cleared ${cleared} cache directories` : "No caches to clear";
+    return { success: true, message };
+}
+export async function openMCPSettings(env = getRuntimeEnv()) {
+    const home = env.homeDir || "";
+    const claudeDir = join(home, ".claude");
+    const settingsPath = join(claudeDir, "settings.json");
+    const fs = createFileSystem();
+    try {
+        await fs.mkdir(claudeDir, { recursive: true });
+    }
+    catch {
+        // Already exists
+    }
+    if (!(await fs.exists(settingsPath))) {
+        const defaultSettings = { mcpServers: {} };
+        await fs.writeTextFile(settingsPath, JSON.stringify(defaultSettings, null, 2));
+    }
+    return openFileInIDE(settingsPath);
+}
+export function quickOpen(projects, num, port) {
+    const index = num - 1;
+    if (index < 0 || index >= projects.length) {
+        return Promise.resolve({ success: false, message: `No project at position ${num}` });
+    }
+    const project = projects[index];
+    return openInBrowser({ slug: project.slug, path: project.path, type: "local" }, port);
+}

package/esm/src/cli/app/components/inline-input.d.ts

@@ -0,0 +1,35 @@
+/****
+ * Inline Text Input Component
+ *
+ * Renders an input prompt at the bottom of the TUI that stays inline
+ * without exiting alternate screen mode.
+ */
+import type { InputState, LogEntry } from "../state.js";
+export interface InlineInputOptions {
+    maxWidth?: number;
+}
+/**
+ * Render the inline input prompt
+ */
+export declare function renderInput(input: InputState, _options?: InlineInputOptions): string;
+export interface RenderLogsOptions {
+    maxLines?: number;
+    maxWidth?: number;
+    scroll?: number;
+    expanded?: boolean;
+}
+/**
+ * Render the logs area with optional scrolling
+ */
+export declare function renderLogs(logs: LogEntry[], options?: RenderLogsOptions): string;
+/**
+ * Handle input key press
+ * Returns the new value and cursor position, or null if the key should end input
+ */
+export declare function handleInputKey(key: string, value: string, cursorPos: number): {
+    value: string;
+    cursorPos: number;
+} | {
+    action: "submit" | "cancel";
+};
+//# sourceMappingURL=inline-input.d.ts.map

package/esm/src/cli/app/components/inline-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-input.d.ts","sourceRoot":"","sources":["../../../../../src/src/cli/app/components/inline-input.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,GAAE,kBAAuB,GAAG,MAAM,CAkBxF;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,QAAQ,EAAE,EAChB,OAAO,GAAE,iBAAsB,GAC9B,MAAM,CA4ER;AAuED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAE,CAiDxE"}