veryfront 0.1.90 → 0.1.92

package/src/src/proxy/tracing.ts

@@ -6,13 +6,9 @@ import * as dntShim from "../../_dnt.shims.js";
 
 
 import type { Context, Span, Tracer } from "@opentelemetry/api";
-import denoConfig from "../../deno.js";
 import { getEnv } from "./env.js";
 import { proxyLogger } from "./logger.js";
-
-// Get version from environment variable or root deno.json
-const VERYFRONT_VERSION: string = getEnv("VERYFRONT_VERSION") ??
-  (typeof denoConfig.version === "string" ? denoConfig.version : "0.0.0");
+import { PROXY_RUNTIME_VERSION } from "./version.js";
 
 let initialized = false;
 let tracerProvider: { shutdown: () => Promise<void> } | null = null;
@@ -100,7 +96,7 @@ export async function initializeOTLPWithApis(): Promise<void> {
     const resourceAttrs = parseResourceAttributes(getEnv("OTEL_RESOURCE_ATTRIBUTES"));
     const resource = new Resource({
       [ATTR_SERVICE_NAME]: config.serviceName,
-      [ATTR_SERVICE_VERSION]: VERYFRONT_VERSION,
+      [ATTR_SERVICE_VERSION]: PROXY_RUNTIME_VERSION,
       ...resourceAttrs,
     });
 

package/src/src/proxy/version.ts

@@ -0,0 +1,21 @@
+import denoConfig from "../../deno.js";
+import { getEnv } from "./env.js";
+
+function normalizeVersion(version: string | undefined): string | undefined {
+  if (!version) return undefined;
+  return version.replace(/^v(?=\d)/, "");
+}
+
+function getVersionEnv(name: string): string | undefined {
+  try {
+    return getEnv(name);
+  } catch {
+    return undefined;
+  }
+}
+
+export const PROXY_RUNTIME_VERSION = normalizeVersion(
+  getVersionEnv("VERYFRONT_VERSION") ?? getVersionEnv("RELEASE_VERSION"),
+) ??
+  normalizeVersion(typeof denoConfig.version === "string" ? denoConfig.version : undefined) ??
+  "0.0.0";

package/src/src/sandbox/index.ts

@@ -19,4 +19,16 @@
 import "../../_dnt.polyfills.js";
 
 
-export { type ExecResult, type ExecStreamEvent, Sandbox, type SandboxOptions } from "./sandbox.js";
+export {
+  type CommandJob,
+  type CommandJobHeartbeatStatus,
+  type CommandJobOutput,
+  type CommandJobStatus,
+  type ExecResult,
+  type ExecStreamEvent,
+  Sandbox,
+  type SandboxListOptions,
+  type SandboxListResult,
+  type SandboxOptions,
+  type SandboxSession,
+} from "./sandbox.js";

package/src/src/sandbox/sandbox.ts

@@ -41,6 +41,60 @@ export interface ExecStreamEvent {
   exitCode?: number;
 }
 
+/** Status of an async command job. */
+export type CommandJobStatus = "running" | "completed" | "failed" | "canceled";
+
+/** Heartbeat health status for a command job. */
+export type CommandJobHeartbeatStatus = "disabled" | "healthy" | "degraded";
+
+/** An async command job running in a sandbox. */
+export interface CommandJob {
+  id: string;
+  status: CommandJobStatus;
+  exitCode: number | null;
+  signal: string | null;
+  startedAt: string;
+  finishedAt: string | null;
+  heartbeatStatus: CommandJobHeartbeatStatus;
+  lastHeartbeatAt: string | null;
+  lastHeartbeatError: string | null;
+  heartbeatFailureCount: number;
+}
+
+/** A command job with its captured output. */
+export interface CommandJobOutput extends CommandJob {
+  stdout: string;
+  stderr: string;
+  stdoutTruncated: boolean;
+  stderrTruncated: boolean;
+}
+
+/** A sandbox session summary returned by list. */
+export interface SandboxSession {
+  id: string;
+  shortId: string;
+  endpoint: string;
+  status: string;
+  createdAt: string;
+}
+
+/** Options for listing sandbox sessions. */
+export interface SandboxListOptions extends SandboxOptions {
+  cursor?: string;
+  limit?: number;
+}
+
+/** Paginated result of sandbox sessions. */
+export interface SandboxListResult {
+  data: SandboxSession[];
+  pageInfo: {
+    self: string | null;
+    first: null;
+    next: string | null;
+    prev: string | null;
+  };
+}
+
 /** Client for isolated ephemeral compute environments with command execution and file I/O. */
 export class Sandbox {
   private constructor(
@@ -117,6 +171,47 @@ export class Sandbox {
     return new Sandbox(endpoint, id, authToken, apiUrl);
   }
 
+  /** List sandbox sessions with optional pagination. */
+  static async list(options: SandboxListOptions = {}): Promise<SandboxListResult> {
+    const apiUrl = Sandbox.resolveApiUrl(options);
+    const authToken = Sandbox.resolveAuthToken(options);
+
+    const params = new URLSearchParams();
+    if (options.cursor) params.set("cursor", options.cursor);
+    if (options.limit !== undefined) params.set("limit", String(options.limit));
+
+    const query = params.toString();
+    const url = `${apiUrl}/sandbox-sessions${query ? `?${query}` : ""}`;
+
+    const res = await dntShim.fetch(url, {
+      headers: { Authorization: `Bearer ${authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Failed to list sandboxes: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    const json = await res.json();
+
+    return {
+      data: json.data.map((s: Record<string, unknown>) => ({
+        id: s.id,
+        shortId: s.short_id,
+        endpoint: s.endpoint,
+        status: s.status,
+        createdAt: s.created_at,
+      })),
+      pageInfo: {
+        self: json.page_info?.self ?? null,
+        first: null,
+        next: json.page_info?.next ?? null,
+        prev: json.page_info?.prev ?? null,
+      },
+    };
+  }
+
   private static async waitForReady(
     apiUrl: string,
     id: string,
@@ -247,6 +342,94 @@ export class Sandbox {
     }
   }
 
+  /** Start an async command job in the sandbox. */
+  async startCommandJob(command: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ command }),
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Start command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  /** Get the status of an async command job. */
+  async getCommandJob(jobId: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}`, {
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Get command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  /** Get the output of an async command job. */
+  async getCommandJobOutput(jobId: string): Promise<CommandJobOutput> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}/output`, {
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Get command job output failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    const json = await res.json();
+    return {
+      ...Sandbox.mapCommandJob(json),
+      stdout: json.stdout,
+      stderr: json.stderr,
+      stdoutTruncated: json.stdout_truncated,
+      stderrTruncated: json.stderr_truncated,
+    };
+  }
+
+  /** Cancel an async command job. */
+  async cancelCommandJob(jobId: string): Promise<CommandJob> {
+    const res = await dntShim.fetch(`${this.endpoint}/exec/jobs/${jobId}/cancel`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.authToken}` },
+    });
+
+    if (!res.ok) {
+      throw REQUEST_ERROR.create({
+        detail: `Cancel command job failed: ${res.status} ${await res.text()}`,
+      });
+    }
+
+    return Sandbox.mapCommandJob(await res.json());
+  }
+
+  private static mapCommandJob(json: Record<string, unknown>): CommandJob {
+    return {
+      id: json.id as string,
+      status: json.status as CommandJobStatus,
+      exitCode: json.exit_code as number | null,
+      signal: json.signal as string | null,
+      startedAt: json.started_at as string,
+      finishedAt: json.finished_at as string | null,
+      heartbeatStatus: json.heartbeat_status as CommandJobHeartbeatStatus,
+      lastHeartbeatAt: json.last_heartbeat_at as string | null,
+      lastHeartbeatError: json.last_heartbeat_error as string | null,
+      heartbeatFailureCount: json.heartbeat_failure_count as number,
+    };
+  }
+
   /** Send a heartbeat to prevent idle timeout. */
   async heartbeat(): Promise<void> {
     await dntShim.fetch(`${this.apiUrl}/sandbox-sessions/${this.sessionId}/heartbeat`, {

package/src/src/server/handlers/dev/styles-css.handler.ts

@@ -11,22 +11,33 @@ import { BaseHandler } from "../response/base.js";
 import type { HandlerContext, HandlerMetadata, HandlerPriority, HandlerResult } from "../types.js";
 import { HTTP_OK, PRIORITY_HIGH_DEV } from "../../../utils/constants/index.js";
 import { joinPath } from "../../../utils/path-utils.js";
-import { formatCSSError, getProjectCSS } from "../../../html/styles-builder/tailwind-compiler.js";
+import {
+  formatCSSError,
+  getCSSByHashAsync,
+  getProjectCSS,
+  regenerateCSSByHash,
+} from "../../../html/styles-builder/tailwind-compiler.js";
 import { DEFAULT_STYLESHEET } from "../../../html/styles-builder/css-hash-cache.js";
 import { resolveStyleContentVersion } from "../../../html/styles-builder/content-version.js";
 import {
   createPreparedProjectCSSContext,
+  type PreparedProjectCSSRequestContext,
   storePreparedProjectCSS,
   tryGetPreparedProjectCSS,
 } from "../../../html/styles-builder/prepared-project-css-cache.js";
 import { createStyleScopeProfile } from "../../../html/styles-builder/style-scope-profile.js";
 import { serverLogger } from "../../../utils/index.js";
 import type { ResolvedContentContext } from "../../../platform/adapters/fs/veryfront/types.js";
+import type {
+  ResolveStyleArtifactInput,
+  VeryfrontApiClient,
+} from "../../../platform/adapters/veryfront-api-client/index.js";
 import { extractProjectCandidates } from "./styles-candidate-scanner.js";
 
 const logger = serverLogger.component("styles-css-handler");
 
 type GeneratedStylesResult = Awaited<ReturnType<typeof getProjectCSS>>;
+type StyleArtifactSelectorContext = Omit<ResolveStyleArtifactInput, "styleProfileHash">;
 
 export class StylesCSSHandler extends BaseHandler {
   metadata: HandlerMetadata = {
@@ -78,6 +89,25 @@ export class StylesCSSHandler extends BaseHandler {
           }
         }
 
+        const remotePrepared = await this.tryResolveRemotePreparedCSS(
+          ctx,
+          projectScope,
+          styleProfile.hash,
+          contentContext,
+          preparedContext,
+        );
+        if (remotePrepared) {
+          logger.debug("Prepared CSS resolved via style artifact metadata", {
+            projectScope,
+            styleProfileHash: styleProfile.hash,
+            cssHash: remotePrepared.hash,
+          });
+
+          return this.respond(
+            responseBuilder.withContentType("text/css; charset=utf-8", remotePrepared.css, HTTP_OK),
+          );
+        }
+
         let candidates: Set<string>;
         try {
           candidates = await extractProjectCandidates(ctx);
@@ -148,6 +178,15 @@ body::before {
           });
         }
 
+        if ("hash" in result) {
+          await this.registerPreparedCSSArtifact(
+            ctx,
+            styleProfile.hash,
+            contentContext,
+            result.hash,
+          );
+        }
+
         return this.respond(
           responseBuilder.withContentType("text/css; charset=utf-8", result.css, HTTP_OK),
         );
@@ -212,6 +251,17 @@ body::before {
     return typeof fsAdapter.getContentContext === "function" ? fsAdapter.getContentContext() : null;
   }
 
+  private getVeryfrontApiClient(ctx: HandlerContext): VeryfrontApiClient | null {
+    const wrappedFs = ctx.adapter.fs as { getUnderlyingAdapter?: () => unknown };
+    if (typeof wrappedFs.getUnderlyingAdapter !== "function") return null;
+
+    const fsAdapter = wrappedFs.getUnderlyingAdapter() as {
+      getClient?: () => VeryfrontApiClient;
+    };
+
+    return typeof fsAdapter.getClient === "function" ? fsAdapter.getClient() : null;
+  }
+
   private createPreparedCSSContext(
     projectScope: string | undefined,
     rawCss: string,
@@ -237,4 +287,132 @@ body::before {
       },
     );
   }
+
+  private resolveStyleArtifactSelector(
+    contentContext: ResolvedContentContext | null,
+    ctx: HandlerContext,
+  ): StyleArtifactSelectorContext | null {
+    if (contentContext?.sourceType === "branch" && contentContext.branch) {
+      return {
+        branch: contentContext.branch,
+      };
+    }
+
+    if (contentContext?.sourceType === "environment" && contentContext.environmentName) {
+      return {
+        environmentName: contentContext.environmentName,
+      };
+    }
+
+    if (contentContext?.sourceType === "release" && contentContext.releaseId) {
+      return {
+        releaseId: contentContext.releaseId,
+      };
+    }
+
+    if (ctx.parsedDomain?.branch) {
+      return {
+        branch: ctx.parsedDomain.branch,
+      };
+    }
+
+    if (ctx.environmentName) {
+      return {
+        environmentName: ctx.environmentName,
+      };
+    }
+
+    if (ctx.releaseId) {
+      return {
+        releaseId: ctx.releaseId,
+      };
+    }
+
+    return null;
+  }
+
+  private async tryResolveRemotePreparedCSS(
+    ctx: HandlerContext,
+    projectScope: string | undefined,
+    styleProfileHash: string,
+    contentContext: ResolvedContentContext | null,
+    preparedContext?: PreparedProjectCSSRequestContext,
+  ): Promise<{ css: string; hash: string } | undefined> {
+    if (!projectScope) return undefined;
+
+    const selector = this.resolveStyleArtifactSelector(contentContext, ctx);
+    if (!selector) return undefined;
+
+    const client = this.getVeryfrontApiClient(ctx);
+    if (!client) return undefined;
+
+    try {
+      const resolved = await client.resolveStyleArtifact({
+        ...selector,
+        styleProfileHash,
+      });
+
+      if (resolved.status !== "ready" || !resolved.artifactHash) {
+        return undefined;
+      }
+
+      const css = await this.getPreparedCSSByHash(resolved.artifactHash, projectScope);
+      if (!css) return undefined;
+
+      if (preparedContext) {
+        await storePreparedProjectCSS(preparedContext, {
+          css,
+          hash: resolved.artifactHash,
+        });
+      }
+
+      return {
+        css,
+        hash: resolved.artifactHash,
+      };
+    } catch (error) {
+      logger.debug("Failed to resolve prepared CSS via style artifact metadata", {
+        projectScope,
+        styleProfileHash,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return undefined;
+    }
+  }
+
+  private async getPreparedCSSByHash(
+    cssHash: string,
+    projectScope: string,
+  ): Promise<string | undefined> {
+    const cached = await getCSSByHashAsync(cssHash);
+    if (cached) return cached;
+    return regenerateCSSByHash(cssHash, projectScope);
+  }
+
+  private async registerPreparedCSSArtifact(
+    ctx: HandlerContext,
+    styleProfileHash: string,
+    contentContext: ResolvedContentContext | null,
+    cssHash: string,
+  ): Promise<void> {
+    const selector = this.resolveStyleArtifactSelector(contentContext, ctx);
+    if (!selector) return;
+
+    const client = this.getVeryfrontApiClient(ctx);
+    if (!client) return;
+
+    try {
+      await client.upsertStyleArtifact({
+        ...selector,
+        styleProfileHash,
+        artifactHash: cssHash,
+      });
+    } catch (error) {
+      logger.debug("Failed to register prepared CSS artifact", {
+        cssHash,
+        styleProfileHash,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
 }

package/src/src/server/handlers/monitoring/health.handler.ts

@@ -4,7 +4,7 @@ import type { HandlerContext, HandlerMetadata, HandlerPriority, HandlerResult }
 import { joinPath } from "../../../utils/path-utils.js";
 import { HTTP_OK, HTTP_UNAVAILABLE, PRIORITY_HIGH } from "../../../utils/constants/index.js";
 import { isTracingDegraded, isTracingEnabled } from "../../../observability/tracing/index.js";
-import { VERSION } from "../../../utils/version.js";
+import { RUNTIME_VERSION } from "../../../utils/version.js";
 
 let serverInitialized = false;
 
@@ -74,7 +74,7 @@ export class HealthHandler extends BaseHandler {
           status: tracingDegraded ? "degraded" : "ok",
           timestamp: new Date().toISOString(),
           mode: hasStaticBuild ? "static+ssr" : "ssr",
-          version: VERSION,
+          version: RUNTIME_VERSION,
           tracing: {
             enabled: isTracingEnabled(),
             degraded: tracingDegraded,

package/src/src/utils/logger/logger.ts

@@ -1,7 +1,7 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { getEnv } from "../../platform/compat/process.js";
 import { hasDenoRuntime, hasNodeProcess } from "../runtime-guards.js";
-import { VERSION } from "../version.js";
+import { RUNTIME_VERSION } from "../version.js";
 import {
   ANSI,
   colorize,
@@ -287,7 +287,7 @@ class ConsoleLogger implements Logger {
       timestamp: new Date().toISOString(),
       level,
       service: this.prefix.toLowerCase(),
-      veryfrontVersion: VERSION,
+      veryfrontVersion: RUNTIME_VERSION,
       message,
     };
 

package/src/src/utils/version.ts

@@ -1,6 +1,41 @@
+import denoConfig from "../../deno.js";
+import { getEnv } from "../platform/compat/process.js";
+
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.89";
+export const VERSION = "0.1.92";
+
+export function normalizeVeryfrontVersion(version: string | undefined): string | undefined {
+  if (!version) return undefined;
+  return version.replace(/^v(?=\d)/, "");
+}
+
+function getVersionEnv(name: string): string | undefined {
+  try {
+    return getEnv(name);
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveRuntimeVersion(options: {
+  veryfrontVersion?: string;
+  releaseVersion?: string;
+  denoVersion?: string;
+  fallbackVersion?: string;
+} = {}): string {
+  return normalizeVeryfrontVersion(options.veryfrontVersion ?? options.releaseVersion) ??
+    normalizeVeryfrontVersion(options.denoVersion) ??
+    options.fallbackVersion ??
+    VERSION;
+}
+
+export const RUNTIME_VERSION = resolveRuntimeVersion({
+  veryfrontVersion: getVersionEnv("VERYFRONT_VERSION"),
+  releaseVersion: getVersionEnv("RELEASE_VERSION"),
+  denoVersion: typeof denoConfig.version === "string" ? denoConfig.version : undefined,
+  fallbackVersion: VERSION,
+});
 
 export const SERVER_START_TIME: number = Date.now();
 
@@ -12,7 +47,7 @@ export interface BuildVersion {
 
 export function createBuildVersion(projectUpdatedAt?: string): BuildVersion {
   return {
-    framework: VERSION,
+    framework: RUNTIME_VERSION,
     serverStart: SERVER_START_TIME,
     projectUpdated: projectUpdatedAt,
   };