@palettelab/cli 0.3.43 → 0.3.44

package/README.md

@@ -328,6 +328,8 @@ async def sync_invoices(ctx: PluginContext = Depends(get_plugin_context)):
     return {"room": room, "folder": folder, "bytes": len(content or b"")}
 ```
 
+App storage is different from Data Room uploads. Use `ctx.storage` or `palette.storage` for app-owned files written directly to the OS-configured storage backend, currently GCS in hosted environments. Use `ctx.data_rooms` / `palette.dataRooms` only when the file should be managed as a Data Room document.
+
 Python backend app-storage example:
 
 ```python

package/docs/python-backend-sdk.md

@@ -740,6 +740,8 @@ Local mocks live in `.palette/app-services.local.json`:
 }
 ```
 
+App storage is separate from Data Rooms. Use `ctx.storage` and `palette.storage` for app-owned files that go directly to the OS-configured storage backend, currently GCS in hosted environments. Use `ctx.data_rooms` or `palette.dataRooms` only when the file should be visible and governed as a Data Room document.
+
 Palette scopes storage the same way. Files written through `ctx.storage` or the
 frontend storage client live under:
 

package/lib/dev-simulator.js

@@ -145,7 +145,7 @@ function ensurePythonEnv(cwd, devDir, manifest) {
   return venvPython
 }
 
-function writeBackendRunner(cwd, devDir, manifest, backendEntry) {
+function writeBackendRunner(cwd, devDir, manifest, backendEntry, backendPort) {
   const runner = path.join(devDir, "backend_runner.py")
   const sdkPath = localBackendSdkPath()
   const databasePath = path.join(devDir, `${manifest.id}.sqlite3`)
@@ -159,10 +159,12 @@ import importlib.util
 import json
 import os
 import pathlib
+import re
 import sys
+import uuid
 from types import SimpleNamespace
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, HTTPException, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -175,6 +177,7 @@ DATABASE_URL = os.environ.get("PALETTE_DEV_DATABASE_URL", "sqlite+aiosqlite:///$
 DEV_SECRETS = json.loads(${JSON.stringify(JSON.stringify(devSecrets))})
 DEV_CONNECTIONS = json.loads(${JSON.stringify(JSON.stringify(devConnections))})
 DEV_APP_MOCKS = json.loads(${JSON.stringify(JSON.stringify(devAppMocks))})
+BACKEND_BASE = "http://127.0.0.1:${backendPort}"
 
 def _service_enabled(name: str) -> bool:
     services = MANIFEST.get("platform_services") or []
@@ -209,6 +212,34 @@ if _service_enabled("storage"):
         organization_name="Palette Dev",
     )
 
+LOCAL_UPLOADS = {}
+CONTENT_RANGE_RE = re.compile(r"^bytes (?P<start>\\d+)-(?P<end>\\d+)/(?P<total>\\d+)$")
+
+def _local_storage_enabled():
+    return _service_enabled("storage") and DEV_STORAGE is not None
+
+def _parse_content_range(value: str | None):
+    if not value:
+        raise HTTPException(status_code=411, detail="Content-Range header is required")
+    match = CONTENT_RANGE_RE.match(value)
+    if not match:
+        raise HTTPException(status_code=400, detail="Invalid Content-Range header")
+    start = int(match.group("start"))
+    end = int(match.group("end"))
+    total = int(match.group("total"))
+    if end < start or total < 0 or end >= total:
+        raise HTTPException(status_code=400, detail="Invalid Content-Range byte range")
+    return start, end, total
+
+def _require_local_storage(plugin_id: str):
+    if plugin_id != MANIFEST.get("id", ""):
+        raise HTTPException(status_code=404, detail="App not found")
+    if not _local_storage_enabled():
+        raise HTTPException(status_code=403, detail='App must declare platform_services: ["storage"]')
+
+def _api_url(path: str):
+    return f"{BACKEND_BASE}/api/v1{path}"
+
 class LocalAppInteropService:
     def service(self, service_id: str):
         return LocalAppServiceClient(service_id)
@@ -310,6 +341,84 @@ app.add_middleware(
 app.add_middleware(DevPluginContextMiddleware)
 app.include_router(router, prefix=f"/api/v1/plugins/{MANIFEST['id']}")
 
+@app.post("/api/v1/app-storage/{plugin_id}/uploads")
+async def create_local_app_storage_upload(plugin_id: str, request: Request):
+    _require_local_storage(plugin_id)
+    body = await request.json()
+    filename = body.get("filename") or "upload"
+    content_type = body.get("content_type") or "application/octet-stream"
+    size = int(body.get("size") or 0)
+    key = body.get("key")
+    chunk_size = int(body.get("chunk_size") or 8 * 1024 * 1024)
+    upload_id = uuid.uuid4().hex
+    object_path = DEV_STORAGE.object_path(filename, key=key)
+    temp_path = DEV_STORAGE._target(f".tmp/app-storage/{upload_id}.part")
+    temp_path.parent.mkdir(parents=True, exist_ok=True)
+    temp_path.write_bytes(b"")
+    LOCAL_UPLOADS[upload_id] = {
+        "plugin_id": plugin_id,
+        "object_path": object_path,
+        "content_type": content_type,
+        "size": size,
+        "uploaded_bytes": 0,
+        "complete": False,
+    }
+    return {
+        "upload_id": upload_id,
+        "mode": "local_resumable",
+        "bucket": "local",
+        "object_path": object_path,
+        "file_url": DEV_STORAGE._target(object_path).as_uri(),
+        "upload_url": _api_url(f"/app-storage/{plugin_id}/uploads/{upload_id}/chunks"),
+        "status_url": _api_url(f"/app-storage/{plugin_id}/uploads/{upload_id}/status"),
+        "content_type": content_type,
+        "size": size,
+        "chunk_size": chunk_size,
+    }
+
+@app.get("/api/v1/app-storage/{plugin_id}/uploads/{upload_id}/status")
+async def local_app_storage_upload_status(plugin_id: str, upload_id: str):
+    _require_local_storage(plugin_id)
+    session = LOCAL_UPLOADS.get(upload_id)
+    if not session or session["plugin_id"] != plugin_id:
+        raise HTTPException(status_code=404, detail="Upload session not found")
+    return {
+        "upload_id": upload_id,
+        "object_path": session["object_path"],
+        "uploaded_bytes": session["uploaded_bytes"],
+        "size": session["size"],
+        "complete": session["complete"],
+        "file_url": DEV_STORAGE._target(session["object_path"]).as_uri(),
+    }
+
+@app.put("/api/v1/app-storage/{plugin_id}/uploads/{upload_id}/chunks")
+async def upload_local_app_storage_chunk(plugin_id: str, upload_id: str, request: Request):
+    _require_local_storage(plugin_id)
+    session = LOCAL_UPLOADS.get(upload_id)
+    if not session or session["plugin_id"] != plugin_id:
+        raise HTTPException(status_code=404, detail="Upload session not found")
+    if session["complete"]:
+        return Response(status_code=204)
+    start, end, total = _parse_content_range(request.headers.get("content-range"))
+    if total != session["size"]:
+        raise HTTPException(status_code=400, detail="Chunk total does not match upload size")
+    if start != session["uploaded_bytes"]:
+        raise HTTPException(status_code=409, detail=f"Expected chunk to start at byte {session['uploaded_bytes']}")
+    payload = await request.body()
+    if len(payload) != end - start + 1:
+        raise HTTPException(status_code=400, detail="Chunk size does not match Content-Range")
+    temp_path = DEV_STORAGE._target(f".tmp/app-storage/{upload_id}.part")
+    with temp_path.open("ab") as fh:
+        fh.write(payload)
+    session["uploaded_bytes"] = end + 1
+    if session["uploaded_bytes"] >= session["size"]:
+        final_path = DEV_STORAGE._target(session["object_path"])
+        final_path.parent.mkdir(parents=True, exist_ok=True)
+        temp_path.replace(final_path)
+        session["complete"] = True
+        return Response(status_code=201)
+    return Response(status_code=308, headers={"Range": f"bytes=0-{session['uploaded_bytes'] - 1}"})
+
 @app.on_event("startup")
 async def create_local_database_tables():
     if engine is None:
@@ -328,7 +437,7 @@ function startBackend(cwd, devDir, manifest, backendPort) {
   if (!fs.existsSync(absEntry)) throw new Error(`backend entry not found: ${backendEntry}`)
 
   const python = ensurePythonEnv(cwd, devDir, manifest)
-  const runner = writeBackendRunner(cwd, devDir, manifest, backendEntry)
+  const runner = writeBackendRunner(cwd, devDir, manifest, backendEntry, backendPort)
   const sdkPath = localBackendSdkPath()
   const env = { ...process.env }
   if (sdkPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@palettelab/cli",
-  "version": "0.3.43",
+  "version": "0.3.44",
   "description": "Developer CLI for building Palette platform plugins — no platform source access required.",
   "bin": {
     "pltt": "bin/pltt.js"