veryfront 0.0.82 → 0.0.84

package/src/proxy/tracing.ts

@@ -0,0 +1,237 @@
+/**
+ * OpenTelemetry OTLP tracing for proxy.
+ * Env: OTEL_TRACES_ENABLED, OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS
+ */
+import * as dntShim from "../_dnt.shims.js";
+
+
+import type { Context, Span, Tracer } from "@opentelemetry/api";
+
+// Inline cross-runtime getEnv to avoid dependency on src/platform/compat (not copied in Docker)
+function getEnv(key: string): string | undefined {
+  // Deno
+  if (typeof dntShim.Deno !== "undefined" && dntShim.Deno.env?.get) {
+    return dntShim.Deno.env.get(key);
+  }
+  // Node.js / Bun
+  const nodeProcess = (dntShim.dntGlobalThis as { process?: { env?: Record<string, string> } }).process;
+  return nodeProcess?.env?.[key];
+}
+
+let initialized = false;
+let tracerProvider: { shutdown: () => Promise<void> } | null = null;
+let tracer: Tracer | null = null;
+
+interface OTLPConfig {
+  serviceName: string;
+  endpoint: string;
+  headers?: Record<string, string>;
+  enabled: boolean;
+}
+
+function parseHeaders(headerString: string | undefined): Record<string, string> {
+  if (!headerString) return {};
+  const headers: Record<string, string> = {};
+  for (const part of headerString.split(",")) {
+    const [key, ...valueParts] = part.split("=");
+    if (key && valueParts.length > 0) {
+      headers[key.trim()] = valueParts.join("=").trim();
+    }
+  }
+  return headers;
+}
+
+function getConfig(): OTLPConfig {
+  return {
+    enabled: getEnv("OTEL_TRACES_ENABLED") === "true",
+    serviceName: getEnv("OTEL_SERVICE_NAME") || "veryfront-proxy",
+    endpoint: getEnv("OTEL_EXPORTER_OTLP_ENDPOINT") || "",
+    headers: parseHeaders(getEnv("OTEL_EXPORTER_OTLP_HEADERS")),
+  };
+}
+
+let traceApi: typeof import("@opentelemetry/api") | null = null;
+let propagationApi: typeof import("@opentelemetry/core") | null = null;
+
+async function loadApis(): Promise<void> {
+  if (traceApi) return;
+  traceApi = await import("@opentelemetry/api");
+  propagationApi = await import("@opentelemetry/core");
+}
+
+export async function initializeOTLP(): Promise<void> {
+  if (initialized) return;
+
+  const config = getConfig();
+
+  if (!config.enabled) {
+    initialized = true;
+    return;
+  }
+
+  if (!config.endpoint) {
+    console.warn("[otel] No endpoint configured");
+    initialized = true;
+    return;
+  }
+
+  try {
+    const { trace } = await import("@opentelemetry/api");
+    const { BasicTracerProvider, BatchSpanProcessor } = await import(
+      "@opentelemetry/sdk-trace-base"
+    );
+    const { OTLPTraceExporter } = await import("@opentelemetry/exporter-trace-otlp-http");
+    const { Resource } = await import("@opentelemetry/resources");
+    const { ATTR_SERVICE_NAME } = await import("@opentelemetry/semantic-conventions");
+
+    const resource = new Resource({ [ATTR_SERVICE_NAME]: config.serviceName });
+    const exporter = new OTLPTraceExporter({
+      url: `${config.endpoint}/v1/traces`,
+      headers: config.headers,
+    });
+
+    const provider = new BasicTracerProvider({ resource });
+    provider.addSpanProcessor(new BatchSpanProcessor(exporter));
+    provider.register();
+
+    tracerProvider = provider;
+    tracer = trace.getTracer(config.serviceName);
+    initialized = true;
+
+    await loadApis();
+
+    console.log("[otel] Initialized", {
+      serviceName: config.serviceName,
+      endpoint: config.endpoint,
+    });
+  } catch (error) {
+    console.error("[otel] Init failed", { error });
+    initialized = true;
+  }
+}
+
+export async function shutdownOTLP(): Promise<void> {
+  if (tracerProvider) {
+    try {
+      await tracerProvider.shutdown();
+      console.log("[otel] Shutdown complete");
+    } catch (error) {
+      console.warn("[otel] Shutdown error", { error });
+    }
+  }
+}
+
+export function isOTLPEnabled(): boolean {
+  return initialized && tracerProvider !== null;
+}
+
+export function extractContext(headers: dntShim.Headers): Context | undefined {
+  if (!traceApi || !propagationApi) return undefined;
+  const carrier: Record<string, string> = {};
+  headers.forEach((v, k) => (carrier[k.toLowerCase()] = v));
+  return new propagationApi.W3CTraceContextPropagator().extract(
+    traceApi.context.active(),
+    carrier,
+    traceApi.defaultTextMapGetter,
+  );
+}
+
+export function injectContext(headers: dntShim.Headers): void {
+  if (!traceApi || !propagationApi) return;
+  const carrier: Record<string, string> = {};
+  new propagationApi.W3CTraceContextPropagator().inject(
+    traceApi.context.active(),
+    carrier,
+    traceApi.defaultTextMapSetter,
+  );
+  Object.entries(carrier).forEach(([k, v]) => headers.set(k, v));
+}
+
+export function startServerSpan(
+  method: string,
+  path: string,
+  parentContext?: Context,
+): { span: Span; context: Context } | null {
+  if (!traceApi || !tracer) return null;
+  const ctx = parentContext || traceApi.context.active();
+  const span = tracer.startSpan(`${method} ${path}`, { kind: traceApi.SpanKind.SERVER }, ctx);
+  return { span, context: traceApi.trace.setSpan(ctx, span) };
+}
+
+export function endSpan(span: Span | undefined, statusCode: number, error?: Error): void {
+  if (!span || !traceApi) return;
+  span.setAttribute("http.status_code", statusCode);
+  if (error) {
+    span.setStatus({ code: traceApi.SpanStatusCode.ERROR, message: error.message });
+    span.recordException(error);
+  } else if (statusCode >= 400) {
+    span.setStatus({ code: traceApi.SpanStatusCode.ERROR });
+  }
+  span.end();
+}
+
+export function withContext<T>(spanContext: Context, fn: () => Promise<T>): Promise<T> {
+  if (!traceApi) return fn();
+  return traceApi.context.with(spanContext, fn);
+}
+
+export function getTraceContext(): { traceId?: string; spanId?: string } {
+  if (!traceApi) return {};
+  const span = traceApi.trace.getSpan(traceApi.context.active());
+  if (!span) return {};
+  const ctx = span.spanContext();
+  return { traceId: ctx.traceId, spanId: ctx.spanId };
+}
+
+/**
+ * Span names for proxy tracing.
+ */
+export const ProxySpanNames = {
+  PROXY_REQUEST: "proxy.request",
+  PROXY_PROCESS: "proxy.process",
+  PROXY_TOKEN_FETCH: "proxy.token_fetch",
+  PROXY_DOMAIN_LOOKUP: "proxy.domain_lookup",
+  OAUTH_TOKEN_REQUEST: "oauth.token_request",
+  HTTP_CLIENT_FETCH: "http.client.fetch",
+} as const;
+
+/**
+ * Execute an async function within a tracing span.
+ * If tracing is disabled, executes the function directly.
+ */
+export async function withSpan<T>(
+  name: string,
+  fn: () => Promise<T>,
+  attributes?: Record<string, string | number | boolean>,
+): Promise<T> {
+  if (!traceApi || !tracer) {
+    return await fn();
+  }
+
+  const parentContext = traceApi.context.active();
+  const span = tracer.startSpan(name, {
+    kind: traceApi.SpanKind.INTERNAL,
+    attributes,
+  }, parentContext);
+
+  const spanContext = traceApi.trace.setSpan(parentContext, span);
+
+  try {
+    const result = await traceApi.context.with(spanContext, fn);
+    span.setStatus({ code: traceApi.SpanStatusCode.OK });
+    return result;
+  } catch (error) {
+    span.setStatus({
+      code: traceApi.SpanStatusCode.ERROR,
+      message: error instanceof Error ? error.message : String(error),
+    });
+    if (error instanceof Error) {
+      span.recordException(error);
+    }
+    throw error;
+  } finally {
+    span.end();
+  }
+}
+
+export { initializeOTLP as initializeOTLPWithApis };

package/src/src/cache/backend.ts

@@ -671,6 +671,9 @@ export const CacheBackends = {
   httpModule: () =>
     createCacheBackend({ keyPrefix: "http-module", circuitBreakerName: "api-cache-http" }),
 
+  /** SSR module cache for React loader (cross-pod sharing). */
+  ssrModule: () => createCacheBackend({ keyPrefix: "ssr-module" }),
+
   /** Project CSS cache for Tailwind CSS output (cross-pod sharing). */
   projectCSS: () => createCacheBackend({ keyPrefix: "project-css" }),
 };

package/src/src/cache/cache-key-builder.ts

@@ -119,12 +119,3 @@ export function extractCacheKeyContext(handlerCtx: HandlerContext): CacheKeyCont
 }
 
 export type { MultiProjectRequestContextType as MultiProjectRequestContext };
-
-/**
- * @deprecated Use tryGetCacheKeyContext() which auto-detects context
- */
-export function extractCacheKeyContextFromRequestContext(
-  reqCtx: MultiProjectRequestContextType,
-): CacheKeyContext {
-  return extractCacheKeyContextFromMultiProjectContext(reqCtx);
-}

package/src/src/cache/multi-tier.ts

@@ -460,44 +460,3 @@ export class MultiTierCache<T = string> {
     return new Map(results);
   }
 }
-
-/**
- * Create a memory-backed cache tier from a CacheBackend.
- */
-export function createMemoryTier(backend: {
-  get(key: string): Promise<string | null>;
-  set(key: string, value: string, ttlSeconds?: number): Promise<void>;
-  del?(key: string): Promise<void>;
-  getBatch?(keys: string[]): Promise<Map<string, string | null>>;
-  setBatch?(entries: Array<{ key: string; value: string; ttl?: number }>): Promise<void>;
-}): CacheTier<string> {
-  return {
-    name: "memory",
-    get: (key) => backend.get(key),
-    set: (key, value, ttl) => backend.set(key, value, ttl),
-    delete: backend.del?.bind(backend),
-    getBatch: backend.getBatch?.bind(backend),
-    setBatch: backend.setBatch?.bind(backend),
-  };
-}
-
-/**
- * Create a distributed cache tier from a CacheBackend.
- */
-export function createDistributedTier(backend: {
-  readonly type: string;
-  get(key: string): Promise<string | null>;
-  set(key: string, value: string, ttlSeconds?: number): Promise<void>;
-  del?(key: string): Promise<void>;
-  getBatch?(keys: string[]): Promise<Map<string, string | null>>;
-  setBatch?(entries: Array<{ key: string; value: string; ttl?: number }>): Promise<void>;
-}): CacheTier<string> {
-  return {
-    name: `distributed-${backend.type}`,
-    get: (key) => backend.get(key),
-    set: (key, value, ttl) => backend.set(key, value, ttl),
-    delete: backend.del?.bind(backend),
-    getBatch: backend.getBatch?.bind(backend),
-    setBatch: backend.setBatch?.bind(backend),
-  };
-}

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

@@ -0,0 +1,190 @@
+/**
+ * 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 type { ProjectInfo } from "./state.js";
+import { getRuntimeEnv, type RuntimeEnv } from "../../config/runtime-env.js";
+
+export type IDE = "cursor" | "code" | "zed" | "idea" | "webstorm";
+
+export interface ActionResult {
+  success: boolean;
+  message?: string;
+}
+
+/** IDE command-line executables */
+const IDE_COMMANDS: Record<IDE, string> = {
+  cursor: "cursor",
+  code: "code",
+  zed: "zed",
+  idea: "idea",
+  webstorm: "webstorm",
+};
+
+/** IDE display names */
+const IDE_NAMES: Record<IDE, string> = {
+  cursor: "Cursor",
+  code: "VS Code",
+  zed: "Zed",
+  idea: "IntelliJ IDEA",
+  webstorm: "WebStorm",
+};
+
+/** IDE detection order (preferred first) */
+const IDE_DETECTION_ORDER: IDE[] = ["cursor", "code", "zed", "idea", "webstorm"];
+
+/** Cache directories to clear relative to project path */
+const PROJECT_CACHE_DIRS = [".cache", "node_modules/.cache"];
+
+function formatError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function commandExists(cmd: string): Promise<boolean> {
+  try {
+    const whichCmd = getOsType() === "windows" ? "where" : "which";
+    const result = await runCommand(whichCmd, { args: [cmd] });
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+
+async function runCommandLocal(cmd: string, args: string[]): Promise<boolean> {
+  try {
+    const result = await runCommand(cmd, { args });
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+
+export async function openInBrowser(project: ProjectInfo, port: number): Promise<ActionResult> {
+  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: ProjectInfo): Promise<ActionResult> {
+  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(): Promise<IDE[]> {
+  const available: IDE[] = [];
+
+  for (const ide of IDE_DETECTION_ORDER) {
+    if (await commandExists(IDE_COMMANDS[ide])) {
+      available.push(ide);
+    }
+  }
+
+  return available;
+}
+
+export async function getPreferredIDE(): Promise<IDE | null> {
+  const ides = await detectIDEs();
+  return ides[0] ?? null;
+}
+
+async function openPathInIDE(path: string, ide?: IDE): Promise<ActionResult> {
+  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: ProjectInfo, ide?: IDE): Promise<ActionResult> {
+  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: string, ide?: IDE): Promise<ActionResult> {
+  return openPathInIDE(filePath, ide);
+}
+
+export async function clearProjectCache(project: ProjectInfo): Promise<ActionResult> {
+  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: RuntimeEnv = getRuntimeEnv()): Promise<ActionResult> {
+  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: Array<{ slug: string; path: string }>,
+  num: number,
+  port: number,
+): Promise<ActionResult> {
+  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);
+}