@opengeni/api-router 0.22.2 → 0.26.1

package/src/routes/files.ts

@@ -8,6 +8,10 @@ import {
   RETAINED_OUTPUT_MAX_PAGE_BYTES,
   RetainedArtifactMetadataSchema,
   retainedArtifactReferenceFromFile,
+  retainedGeneratedImageReferenceFromFile,
+  retainedGeneratedVideoReferenceFromFile,
+  retainedScreenshotReferenceFromFile,
+  VideoArtifactPlaybackSource,
   resolveRetainedOutputRange,
   type RetainedArtifactMetadata,
   type RetainedOutputUnavailableReason,
@@ -18,11 +22,17 @@ import {
   completeFileUpload,
   createFileUpload,
   getFileUpload,
+  getGeneratedImageArtifact,
+  getGeneratedVideoArtifact,
   getRetainedFileArtifact,
+  getRetainedScreenshotArtifact,
   requireFile,
   type RetainedFileArtifact,
+  type GeneratedImageArtifact,
+  type GeneratedVideoArtifact,
+  type RetainedScreenshotArtifact,
 } from "@opengeni/db";
-import type { Hono } from "hono";
+import type { Context, Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { requireAccessGrant } from "@opengeni/core";
 import { recordWorkspaceUsage, requireLimit } from "@opengeni/core";
@@ -36,7 +46,9 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
   app.all("/v1/workspaces/:workspaceId/mcp/files", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "files:read");
-    const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      enableJsonResponse: true,
+    });
     const server = buildFilesMcpServer(deps, grant);
     await server.connect(transport);
     return await transport.handleRequest(c.req.raw);
@@ -46,7 +58,9 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "files:upload");
     if (!objectStorage) {
-      throw new HTTPException(503, { message: "object storage is not configured" });
+      throw new HTTPException(503, {
+        message: "object storage is not configured",
+      });
     }
     const payload = CreateFileUploadRequest.parse(await c.req.json());
     await requireLimit(deps, {
@@ -98,7 +112,9 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     const grant = await requireAccessGrant(c, deps, workspaceId, "files:upload");
     if (!objectStorage) {
-      throw new HTTPException(503, { message: "object storage is not configured" });
+      throw new HTTPException(503, {
+        message: "object storage is not configured",
+      });
     }
     const upload = await getFileUpload(db, workspaceId, c.req.param("uploadId"));
     if (!upload) {
@@ -186,7 +202,9 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
         terminalStatus,
       });
       if (!settled) {
-        throw new HTTPException(409, { message: "file upload cleanup claim was superseded" });
+        throw new HTTPException(409, {
+          message: "file upload cleanup claim was superseded",
+        });
       }
       throw new HTTPException(status, { message });
     };
@@ -259,91 +277,112 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "files:read");
     const artifactId = retainedArtifactId(c.req.param("artifactId"));
-    const artifact = await getRetainedFileArtifact(db, workspaceId, artifactId);
+    const artifact = await getWorkspaceArtifact(db, workspaceId, artifactId);
     if (!artifact) {
       return c.json(retainedArtifactUnavailable(artifactId, "deleted"), 404);
     }
-    return c.json(retainedArtifactMetadata(artifact));
+    return c.json(artifact.metadata);
   });
 
   app.get("/v1/workspaces/:workspaceId/artifacts/:artifactId/content", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "files:read");
     const artifactId = retainedArtifactId(c.req.param("artifactId"));
-    const artifact = await getRetainedFileArtifact(db, workspaceId, artifactId);
+    const artifact = await getWorkspaceArtifact(db, workspaceId, artifactId);
     if (!artifact) {
       return c.json(retainedArtifactUnavailable(artifactId, "deleted"), 404);
     }
 
-    const metadata = retainedArtifactMetadata(artifact);
-    if (!metadata.available) {
-      return c.json(metadata, retainedArtifactUnavailableStatus(metadata.reason));
-    }
+    return await serveRetainedArtifactContent(
+      c,
+      objectStorage,
+      artifactId,
+      artifact.file,
+      artifact.metadata,
+    );
+  });
+
+  app.post("/v1/workspaces/:workspaceId/artifacts/:artifactId/playback-source", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "files:read");
     if (!objectStorage) {
-      return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 503);
+      throw new HTTPException(503, { message: "object storage is not configured" });
     }
-
-    const rangeHeader = c.req.header("range");
-    const range = resolveRetainedOutputRange(
-      rangeHeader,
-      metadata.originalBytes,
-      rangeHeader ? RETAINED_OUTPUT_MAX_PAGE_BYTES : RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
-    );
-    if (range.kind === "invalid") {
-      return c.json(
-        {
-          message: "invalid retained artifact byte range",
-          reason: range.reason,
-          maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES,
-        },
-        400,
-      );
+    const artifactId = retainedArtifactId(c.req.param("artifactId"));
+    const retained = await getGeneratedVideoArtifact(db, workspaceId, artifactId);
+    if (!retained || retained.artifact.deletedAt) {
+      throw new HTTPException(404, { message: "generated video not found" });
     }
-    if (range.kind === "unsatisfiable") {
-      return c.json(
-        { message: "retained artifact byte range is not satisfiable", reason: range.reason },
-        416,
-        {
-          "Accept-Ranges": "bytes",
-          "Content-Range": range.contentRange,
-          "Cache-Control": "private, no-store",
-        },
-      );
+    if (retained.file.status !== "ready") {
+      throw new HTTPException(409, { message: `generated video is ${retained.file.status}` });
     }
-
-    const headers = {
-      "Accept-Ranges": range.acceptRanges,
-      "Cache-Control": "private, no-store",
-      "Content-Length": String(range.length),
-      "Content-Type": metadata.contentType,
-      "X-Content-Type-Options": "nosniff",
-      ...(range.contentRange ? { "Content-Range": range.contentRange } : {}),
-    };
-    if (range.kind === "empty") {
-      if (!(await objectStorage.fileExists(artifact.file))) {
-        return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 410);
-      }
-      return c.body(null, 200, headers);
+    const file = generatedVideoFileAsset(retained.file);
+    if (!(await objectStorage.fileExists(file))) {
+      throw new HTTPException(410, { message: "generated video bytes are unavailable" });
     }
+    const signed = await objectStorage.createGetUrl({ key: file.objectKey });
+    return c.json(
+      VideoArtifactPlaybackSource.parse({
+        schemaVersion: 1,
+        artifactId,
+        url: signed.url,
+        expiresAt: signed.expiresAt.toISOString(),
+        contentType: "video/mp4",
+        sizeBytes: file.sizeBytes,
+        sha256: file.sha256,
+        acceptRanges: "bytes",
+      }),
+    );
+  });
 
-    const bytes = await objectStorage.getFileRange(artifact.file, {
-      start: range.start,
-      end: range.end,
-    });
-    if (!bytes) {
-      return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 410);
-    }
-    if (bytes.byteLength !== range.length) {
-      throw new HTTPException(502, { message: "object storage returned an invalid byte range" });
+  app.get("/v1/workspaces/:workspaceId/sessions/:sessionId/artifacts/:artifactId", async (c) => {
+    const workspaceId = c.req.param("workspaceId");
+    await requireAccessGrant(c, deps, workspaceId, "files:read");
+    const artifactId = retainedArtifactId(c.req.param("artifactId"));
+    const artifact = await getRetainedScreenshotArtifact(
+      db,
+      workspaceId,
+      c.req.param("sessionId"),
+      artifactId,
+    );
+    if (!artifact) {
+      return c.json(retainedArtifactUnavailable(artifactId, "deleted"), 404);
     }
-    return c.body(new Uint8Array(bytes), range.status, headers);
+    return c.json(retainedScreenshotMetadata(artifact));
   });
 
+  app.get(
+    "/v1/workspaces/:workspaceId/sessions/:sessionId/artifacts/:artifactId/content",
+    async (c) => {
+      const workspaceId = c.req.param("workspaceId");
+      await requireAccessGrant(c, deps, workspaceId, "files:read");
+      const artifactId = retainedArtifactId(c.req.param("artifactId"));
+      const artifact = await getRetainedScreenshotArtifact(
+        db,
+        workspaceId,
+        c.req.param("sessionId"),
+        artifactId,
+      );
+      if (!artifact) {
+        return c.json(retainedArtifactUnavailable(artifactId, "deleted"), 404);
+      }
+      return await serveRetainedArtifactContent(
+        c,
+        objectStorage,
+        artifactId,
+        artifact.file,
+        retainedScreenshotMetadata(artifact),
+      );
+    },
+  );
+
   app.post("/v1/workspaces/:workspaceId/files/:fileId/download-url", async (c) => {
     const workspaceId = c.req.param("workspaceId");
     await requireAccessGrant(c, deps, workspaceId, "files:read");
     if (!objectStorage) {
-      throw new HTTPException(503, { message: "object storage is not configured" });
+      throw new HTTPException(503, {
+        message: "object storage is not configured",
+      });
     }
     const file = await requireFile(db, workspaceId, c.req.param("fileId")).catch(() => null);
     if (!file) {
@@ -362,6 +401,81 @@ export function registerFileRoutes(app: Hono, deps: ApiRouteDeps): void {
   });
 }
 
+async function serveRetainedArtifactContent(
+  c: Context,
+  objectStorage: ApiRouteDeps["objectStorage"],
+  artifactId: string,
+  file: RetainedFileArtifact["file"],
+  metadata: RetainedArtifactMetadata,
+) {
+  if (!metadata.available) {
+    return c.json(metadata, retainedArtifactUnavailableStatus(metadata.reason));
+  }
+  if (!objectStorage) {
+    return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 503);
+  }
+
+  const rangeHeader = c.req.header("range");
+  const range = resolveRetainedOutputRange(
+    rangeHeader,
+    metadata.originalBytes,
+    rangeHeader ? RETAINED_OUTPUT_MAX_PAGE_BYTES : RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
+  );
+  if (range.kind === "invalid") {
+    return c.json(
+      {
+        message: "invalid retained artifact byte range",
+        reason: range.reason,
+        maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES,
+      },
+      400,
+    );
+  }
+  if (range.kind === "unsatisfiable") {
+    return c.json(
+      {
+        message: "retained artifact byte range is not satisfiable",
+        reason: range.reason,
+      },
+      416,
+      {
+        "Accept-Ranges": "bytes",
+        "Content-Range": range.contentRange,
+        "Cache-Control": "private, no-store",
+      },
+    );
+  }
+
+  const headers = {
+    "Accept-Ranges": range.acceptRanges,
+    "Cache-Control": "private, no-store",
+    "Content-Length": String(range.length),
+    "Content-Type": metadata.contentType,
+    "X-Content-Type-Options": "nosniff",
+    ...(range.contentRange ? { "Content-Range": range.contentRange } : {}),
+  };
+  if (range.kind === "empty") {
+    if (!(await objectStorage.fileExists(file))) {
+      return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 410);
+    }
+    return c.body(null, 200, headers);
+  }
+
+  const bytes = await objectStorage.getFileRange(file, {
+    start: range.start,
+    end: range.end,
+  });
+  if (!bytes) {
+    return c.json(retainedArtifactUnavailable(artifactId, "missing_storage"), 410);
+  }
+  if (bytes.byteLength !== range.length) {
+    throw new HTTPException(502, {
+      message: "object storage returned an invalid byte range",
+    });
+  }
+  return c.body(new Uint8Array(bytes), range.status, headers);
+}
+
 export function sanitizeFilename(filename: string): string {
   const trimmed = filename.trim().replace(/[/\\]/g, "_");
   const safe = trimmed
@@ -388,7 +502,11 @@ function retainedArtifactUnavailable(
   artifactId: string,
   reason: RetainedOutputUnavailableReason,
 ): RetainedArtifactMetadata {
-  return RetainedArtifactMetadataSchema.parse({ available: false, artifactId, reason });
+  return RetainedArtifactMetadataSchema.parse({
+    available: false,
+    artifactId,
+    reason,
+  });
 }
 
 function retainedArtifactMetadata(artifact: RetainedFileArtifact): RetainedArtifactMetadata {
@@ -417,6 +535,97 @@ function retainedArtifactMetadata(artifact: RetainedFileArtifact): RetainedArtif
   return retainedArtifactUnavailable(file.id, "unsupported");
 }
 
+async function getWorkspaceArtifact(
+  db: ApiRouteDeps["db"],
+  workspaceId: string,
+  artifactId: string,
+): Promise<{ file: RetainedFileArtifact["file"]; metadata: RetainedArtifactMetadata } | null> {
+  const generated = await getGeneratedImageArtifact(db, workspaceId, artifactId);
+  if (generated) {
+    return { file: generated.file, metadata: retainedGeneratedImageMetadata(generated) };
+  }
+  const generatedVideo = await getGeneratedVideoArtifact(db, workspaceId, artifactId);
+  if (generatedVideo && !generatedVideo.artifact.deletedAt) {
+    const file = generatedVideoFileAsset(generatedVideo.file);
+    return {
+      file,
+      metadata: retainedGeneratedVideoMetadata({
+        artifact: generatedVideo.artifact,
+        file,
+      }),
+    };
+  }
+  const artifact = await getRetainedFileArtifact(db, workspaceId, artifactId);
+  return artifact ? { file: artifact.file, metadata: retainedArtifactMetadata(artifact) } : null;
+}
+
+function generatedVideoFileAsset(
+  file: NonNullable<Awaited<ReturnType<typeof getGeneratedVideoArtifact>>>["file"],
+): RetainedFileArtifact["file"] {
+  return FileAsset.parse({
+    ...file,
+    createdAt: file.createdAt.toISOString(),
+    updatedAt: file.updatedAt.toISOString(),
+  });
+}
+
+function retainedGeneratedVideoMetadata(artifact: {
+  artifact: GeneratedVideoArtifact;
+  file: RetainedFileArtifact["file"];
+}): RetainedArtifactMetadata {
+  const reference = retainedGeneratedVideoReferenceFromFile({
+    ...artifact.file,
+    id: artifact.artifact.id,
+    width: artifact.artifact.width,
+    height: artifact.artifact.height,
+    updatedAt: artifact.artifact.readyAt.toISOString(),
+  });
+  return reference ?? retainedArtifactUnavailable(artifact.artifact.id, "failed");
+}
+
+function retainedGeneratedImageMetadata(
+  artifact: GeneratedImageArtifact,
+): RetainedArtifactMetadata {
+  if (artifact.status === "ready") {
+    const reference = retainedGeneratedImageReferenceFromFile({
+      ...artifact.file,
+      width: artifact.width,
+      height: artifact.height,
+    });
+    if (reference) return reference;
+  }
+  return retainedArtifactUnavailable(artifact.artifactId, "pending");
+}
+
+function retainedScreenshotMetadata(
+  artifact: RetainedScreenshotArtifact,
+): RetainedArtifactMetadata {
+  if (
+    artifact.status === "ready" &&
+    artifact.sessionId &&
+    artifact.retentionExpiresAt.getTime() > Date.now()
+  ) {
+    const reference = retainedScreenshotReferenceFromFile({
+      ...artifact.file,
+      sessionId: artifact.sessionId,
+      width: artifact.width,
+      height: artifact.height,
+      expiresAt: artifact.retentionExpiresAt.toISOString(),
+    });
+    if (reference) return reference;
+  }
+  if (artifact.status === "deleted") {
+    return retainedArtifactUnavailable(artifact.artifactId, "deleted");
+  }
+  if (artifact.status === "expired" || artifact.retentionExpiresAt.getTime() <= Date.now()) {
+    return retainedArtifactUnavailable(artifact.artifactId, "expired");
+  }
+  if (artifact.status === "pending" || artifact.status === "reconciling") {
+    return retainedArtifactUnavailable(artifact.artifactId, "pending");
+  }
+  return retainedArtifactUnavailable(artifact.artifactId, "failed");
+}
+
 function retainedArtifactUnavailableStatus(
   reason: RetainedOutputUnavailableReason,
 ): 404 | 409 | 410 | 422 {
@@ -429,6 +638,9 @@ function retainedArtifactUnavailableStatus(
     case "unsupported":
     case "not_retained":
     case "storage_write_failed":
+    case "quota_exceeded":
+    case "invalid_content":
+    case "oversized":
       return 422;
     case "pending":
     case "failed":

package/src/routes/github.ts

@@ -38,6 +38,7 @@ import {
   githubBrowserBaseUrl,
   githubBrowserGrantClaims,
   githubBrowserGrantFromState,
+  githubSessionReturnPath,
 } from "../github-browser-flow";
 import {
   githubBindingStatus,
@@ -64,12 +65,14 @@ export function registerGitHubRoutes(app: Hono, deps: ApiRouteDeps): void {
     const status = githubBindingStatus(missing.length === 0, installations);
     const setupMode = settings.productAccessMode === "managed" ? "platform" : "operator";
     const canManage = hasPermission(grant.permissions, "github:manage");
+    const returnPath = githubSessionReturnPath(c.req.query("returnPath"), grant.workspaceId);
     const connectState =
       missing.length === 0 && slug && canManage
         ? createSignedState(githubStateSecret, {
             accountId: grant.accountId,
             workspaceId: grant.workspaceId,
             intent: "installation_authority",
+            ...(returnPath ? { returnPath } : {}),
             ...githubBrowserGrantClaims(settings, grant),
           })
         : null;
@@ -517,7 +520,12 @@ export function registerGitHubRoutes(app: Hono, deps: ApiRouteDeps): void {
     return c.html(
       githubSetupSuccessHtml(
         proof.installation.accountLogin ?? `installation ${installationId}`,
-        openGeniReturnUrl(settings, c, grant.workspaceId),
+        openGeniReturnUrl(
+          settings,
+          c,
+          grant.workspaceId,
+          typeof statePayload.returnPath === "string" ? statePayload.returnPath : null,
+        ),
       ),
     );
   });
@@ -879,8 +887,16 @@ function openGeniReturnUrl(
   settings: ApiRouteDeps["settings"],
   c: Context,
   workspaceId: string,
+  returnPath: string | null = null,
 ): string {
-  const url = new URL(openGeniBaseUrl(settings, c) || new URL(c.req.url).origin);
+  const baseUrl = openGeniBaseUrl(settings, c) || new URL(c.req.url).origin;
+  const safeReturnPath = githubSessionReturnPath(returnPath, workspaceId);
+  const url = safeReturnPath ? new URL(safeReturnPath, `${baseUrl}/`) : new URL(baseUrl);
+  if (safeReturnPath) {
+    url.searchParams.delete("capability_auth");
+    url.searchParams.set("github", "connected");
+    return url.toString();
+  }
   url.searchParams.set("workspaceId", workspaceId);
   return url.toString();
 }

package/src/routes/install.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import type { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
@@ -27,7 +28,12 @@ import type { ApiRouteDeps } from "@opengeni/core";
 // The committed install artifacts, resolved relative to this module so the API
 // (run from source under /app via bun) locates the sibling agent/install/ dir at
 // runtime. apps/api/src/routes -> ../../../../agent/install.
-const INSTALL_DIR = new URL("../../../../agent/install/", import.meta.url);
+const INSTALL_DIR =
+  [
+    new URL("./assets/agent-install/", import.meta.url),
+    new URL("../../../../agent/install/", import.meta.url),
+  ].find((candidate) => existsSync(candidate)) ??
+  new URL("../../../../agent/install/", import.meta.url);
 
 // The baked release-binary dir (a sibling of the committed scripts). The build's
 // signing step writes the per-SHA Linux musl binaries + their `.sha256`/`.minisig`
@@ -200,6 +206,31 @@ export function registerInstallRoutes(app: Hono, deps: ApiRouteDeps): void {
     return serveAsset(asset, `${releasesBase}/download/${stableAgentTag}/${asset}`);
   });
 
+  // Signed self-update channel manifests. Each deployment exposes its own
+  // immutable promotion pointer, so an enrolled machine never depends on the
+  // public get.opengeni.ai hostname. The manifest and signature are ordinary
+  // assets on the selected immutable agent release.
+  for (const [channel, version] of [
+    ["stable", deps.settings.agentStableVersion],
+    ["beta", deps.settings.agentBetaVersion],
+  ] as const) {
+    app.get(`/agent/${channel}/:manifestAsset`, (c) => {
+      const manifestAsset = c.req.param("manifestAsset");
+      if (manifestAsset !== "manifest.json" && manifestAsset !== "manifest.json.minisig") {
+        throw new HTTPException(404, { message: "update manifest asset not found" });
+      }
+      if (!version) {
+        throw new HTTPException(404, { message: `${channel} agent channel is not configured` });
+      }
+      return new Response(null, {
+        status: 302,
+        headers: {
+          location: `${releasesBase}/download/agent-v${version}/${manifestAsset}`,
+        },
+      });
+    });
+  }
+
   // The version segment is the literal `v<ver>` (e.g. `v1.2.3`) — Hono cannot bind
   // a param glued to a literal prefix, so the whole segment is the param and the
   // `v` prefix is validated/stripped here. The release tag is `agent-v<ver>`.
@@ -220,5 +251,10 @@ export function registerInstallRoutes(app: Hono, deps: ApiRouteDeps): void {
 export const installExactPaths: ReadonlySet<string> = new Set(Object.keys(TEXT_ASSETS));
 
 export function isInstallRedirectPath(path: string): boolean {
-  return path.startsWith("/agent/latest/") || path.startsWith("/agent/v");
+  return (
+    path.startsWith("/agent/latest/") ||
+    path.startsWith("/agent/v") ||
+    path.startsWith("/agent/stable/") ||
+    path.startsWith("/agent/beta/")
+  );
 }