@springbrand/space 0.2.0-alpha.16 → 0.2.0-alpha.17

package/src/space/workspace-port.ts

@@ -28,6 +28,11 @@ export interface SpaceFileInfo {
   createdAt: number;
   updatedAt: number;
   target?: string;
+  attachmentId?: string;
+  contentVersion?: string;
+  cdnUrl?: string;
+  origin?: "user_upload" | "https_import" | "action" | "agent" | "userspace";
+  understandingStatus?: "not_requested" | "pending" | "ready" | "failed" | "unsupported";
 }
 
 /**
@@ -202,11 +207,13 @@ export interface SpaceWorkspacePort {
   symlink(target: string, linkPath: string): Promise<void>;
   readlink(path: string): Promise<string>;
   glob(pattern: string): Promise<SpaceFileInfo[]>;
+  inspectFile(path: string): Promise<import("./space-files").SpaceFileInspection | null>;
 }
 
 export interface SpaceStreamWriteOptions {
   contentLength?: number;
   mediaType?: string;
+  origin?: import("./space-files").SpaceFileOrigin;
 }
 
 /**
@@ -217,6 +224,16 @@ export interface SpaceStreamWriteOptions {
  * accident, and so the runtime's contract stays exactly the file surface.
  */
 export interface SpaceControlPort {
+  registerExistingContents(
+    input: import("./space-files").RegisterExistingContentsInput,
+  ): Promise<import("./space-files").SpaceFileInspection[] | null>;
+  setFileUnderstanding(
+    path: string,
+    contentVersion: string,
+    status: import("./space-files").SpaceUnderstandingStatus,
+    evidence?: import("./space-files").SpaceFileEvidence,
+  ): Promise<import("./space-files").SpaceFileInspection>;
+  beginFileUnderstanding(path: string, contentVersion: string, refresh?: boolean): Promise<boolean>;
   writeFileBytesIfUnchanged(
     path: string,
     data: Uint8Array,

package/src/space/workspace-site.ts

@@ -0,0 +1,116 @@
+const DEPLOYMENT_PATH = new RegExp(
+  "^/(spaces/v1/[^/%]+/deployments/[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})(?:/(.*))?$",
+  "u",
+)
+
+type WorkspaceSiteBucket = Pick<R2Bucket, "get" | "head">
+
+/** Serve immutable Workspace Site assets without routing static bytes through SpaceDO. */
+export async function handleWorkspaceSiteRequest(
+  request: Request,
+  input: { origin: string; bucket: WorkspaceSiteBucket },
+): Promise<Response | null> {
+  const url = new URL(request.url)
+  if (url.origin !== new URL(input.origin).origin || !url.pathname.startsWith("/spaces/v1/")) {
+    return null
+  }
+  if (/%2f|%5c/iu.test(url.pathname)) return notFound()
+
+  let pathname: string
+  try {
+    pathname = decodeURIComponent(url.pathname)
+  } catch {
+    return notFound()
+  }
+  const match = DEPLOYMENT_PATH.exec(pathname)
+  if (!match) return null
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } })
+  }
+
+  const assetRoot = match[1]!
+  const requestedPath = match[2] ?? ""
+  if (requestedPath.split("/").some((part) => part === "." || part === ".." || /[\p{Cc}]/u.test(part))) {
+    return notFound()
+  }
+  const candidates = assetCandidates(requestedPath)
+  for (const candidate of candidates) {
+    const key = `${assetRoot}/${candidate}`
+    const rangeHeader = request.method === "GET" ? request.headers.get("Range") : null
+    const rangeRequest = rangeHeader && isSingleByteRange(rangeHeader) ? rangeHeader : null
+    const object = request.method === "HEAD"
+      ? await input.bucket.head(key)
+      : await input.bucket.get(key, rangeRequest
+        ? { range: request.headers }
+        : undefined)
+    if (!object) continue
+
+    const headers = new Headers()
+    object.writeHttpMetadata(headers)
+    headers.set("ETag", object.httpEtag)
+    headers.set("Cache-Control", "public, max-age=31536000, immutable")
+    headers.set("Accept-Ranges", "bytes")
+    const range = rangeRequest ? rangeBounds(rangeRequest, object.size) : null
+    headers.set("Content-Length", String(range?.length ?? object.size))
+    if (range) {
+      headers.set(
+        "Content-Range",
+        `bytes ${range.offset}-${range.offset + range.length - 1}/${object.size}`,
+      )
+    }
+    const response = new Response(
+      request.method === "HEAD" ? null : (object as R2ObjectBody).body,
+      { status: range ? 206 : 200, headers },
+    )
+    return request.method === "GET" && headers.get("Content-Type")?.includes("text/html")
+      ? rewriteHtml(response, `/${assetRoot}`)
+      : response
+  }
+  return notFound()
+}
+
+function isSingleByteRange(value: string): boolean {
+  return /^bytes=(?:\d+-\d*|-\d+)$/u.test(value)
+}
+
+function rangeBounds(value: string, size: number): { offset: number; length: number } {
+  const [startText, endText] = value.slice("bytes=".length).split("-", 2)
+  if (!startText) {
+    const length = Math.min(Number(endText), size)
+    return { offset: size - length, length }
+  }
+  const offset = Number(startText)
+  const end = endText ? Math.min(Number(endText), size - 1) : size - 1
+  return { offset, length: end - offset + 1 }
+}
+
+function assetCandidates(path: string): string[] {
+  if (!path) return ["index.html"]
+  if (path.endsWith("/")) return [`${path}index.html`]
+  return path.split("/").at(-1)?.includes(".") ? [path] : [path, `${path}.html`]
+}
+
+function rewriteHtml(response: Response, siteBasePath: string): Response {
+  const headers = new Headers(response.headers)
+  headers.delete("Content-Length")
+  headers.delete("ETag")
+  return new HTMLRewriter()
+    .on("[src],[href],[action]", {
+      element(element) {
+        for (const attribute of ["src", "href", "action"] as const) {
+          const value = element.getAttribute(attribute)
+          if (value?.startsWith("/") && !value.startsWith("//")) {
+            element.setAttribute(attribute, siteBasePath + value)
+          }
+        }
+      },
+    })
+    .transform(new Response(response.body, { status: response.status, headers }))
+}
+
+function notFound(): Response {
+  return new Response("Not Found", {
+    status: 404,
+    headers: { "Content-Type": "text/plain; charset=utf-8" },
+  })
+}