veryfront 0.1.90 → 0.1.91

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),
+      });
+    }
+  }
 }