create-loopengine 0.1.43 → 0.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/adapters/http.ts

@@ -137,6 +137,7 @@ import {
 import { SkillGarden } from 'loopengine'
 import type { Decision, PendingApproval } from 'actauth'
 import type { LoopEvent } from 'loopengine'
+import { storageSigners } from 'loopengine'
 
 const sessions = createSessionStore()
 const checkpoints = createCheckpointStore()
@@ -2038,6 +2039,76 @@ async function respondAfterResolution(res: ServerResponse, finalCheckpoint: Turn
   )
 }
 
+// A generated image/archive's own signed cloud-storage URL is a long,
+// high-entropy string (a GCS V4 Signature can run ~300 base64
+// characters) that an agent's own reply has to reproduce character-for-
+// character to embed as a markdown image/link — expensive in output
+// tokens, slow to generate, and one flipped character anywhere in it
+// breaks the whole thing. This route lets a tool return a short, stable
+// object reference instead — bucket + object name, both human-readable,
+// not random — and defer the actual signing to request time, right
+// here, freshly, on every click: shorter for the model to write,
+// nothing random left to transcribe wrong, and a much shorter
+// signed-URL lifetime than an ability calling getSignedUrl itself at
+// generation time ever needed (this one only has to stay valid for as
+// long as the click that requested it takes to resolve, not however
+// long a chat reply might sit around unopened).
+//
+// Deliberately generic on two axes, not tied to any one ability or
+// cloud provider: any ability can point a tool's own returned URL here
+// instead of signing itself, as long as it authenticates the same way
+// loopengine's own storageSigners.gcs already does
+// (GOOGLE_APPLICATION_CREDENTIALS_JSON, falling back to Application
+// Default Credentials) — that's the same logic
+// lp-product-ad-images'/lp-file-archiver's own buildGcsStorageClient
+// already duplicate for the *upload* side, centralized in loopengine
+// core for signing instead. `provider` picks which one of
+// loopengine's own storageSigners actually does the signing (only
+// `gcs` exists today) — adding S3/Azure/etc. later is a loopengine
+// core change, not something this scaffolded file needs to know about.
+//
+// Sits behind the same isAuthorized() Basic Auth gate every other route
+// on this server already requires (checked once, unconditionally,
+// before any routing below even runs) — not a separately public
+// endpoint. A browser that already loaded /playground has that same
+// origin's Basic Auth credentials cached, so a plain
+// <img src="/storage-redirect?..."> or download link both just work
+// with no extra wiring; anything without those credentials gets the
+// same 401 every other route already gives it.
+async function handleStorageRedirect(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  const url = new URL(req.url ?? '/', 'http://localhost')
+  const provider = url.searchParams.get('provider')
+  const bucket = url.searchParams.get('bucket')
+  const object = url.searchParams.get('object')
+  const disposition = url.searchParams.get('disposition')
+  const filename = url.searchParams.get('filename')
+
+  if (!provider || !bucket || !object) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'storage-redirect requires provider, bucket, and object query params' }))
+    return
+  }
+  if (disposition && disposition !== 'inline' && disposition !== 'attachment') {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `disposition must be "inline" or "attachment" — got "${disposition}"` }))
+    return
+  }
+  const signer = storageSigners[provider]
+  if (!signer) {
+    res.writeHead(400, { 'content-type': 'application/json' }).end(
+      JSON.stringify({ error: `storage-redirect: unknown provider "${provider}" — supported: ${Object.keys(storageSigners).join(', ')}` }),
+    )
+    return
+  }
+
+  try {
+    const signedUrl = await signer({ bucket, object, disposition: (disposition as 'inline' | 'attachment' | null) ?? undefined, filename: filename ?? undefined })
+    res.writeHead(302, { location: signedUrl }).end()
+  } catch (err) {
+    res
+      .writeHead(502, { 'content-type': 'application/json' })
+      .end(JSON.stringify({ error: `storage-redirect: could not sign a URL for ${provider}://${bucket}/${object}: ${err instanceof Error ? err.message : String(err)}` }))
+  }
+}
+
 const server = createServer(async (req, res) => {
   if (!isAuthorized(req)) {
     res
@@ -2484,6 +2555,11 @@ const server = createServer(async (req, res) => {
       return
     }
 
+    if (req.method === 'GET' && pathname === '/storage-redirect') {
+      await handleStorageRedirect(req, res)
+      return
+    }
+
     const match = req.method === 'POST' && pathname.match(/^\/agents\/([^/]+)\/messages$/)
     if (!match) {
       res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'not found' }))