@palettelab/cli 0.3.45 → 0.3.46

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"")}
 ```
 
+Storage upload responses include both snake_case and camelCase aliases for object metadata (`object_path`/`objectPath`, `file_url`/`fileUrl`, `content_type`/`contentType`) so local simulator and hosted OS responses can be consumed with the same app code.
+
 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:

package/backend-sdk/palette_sdk/storage.py

@@ -83,6 +83,47 @@ def _content_type(filename: str | None, content_type: str | None) -> str:
     return browser_ct
 
 
+def _storage_metadata(
+    *,
+    bucket: str,
+    object_path: str,
+    file_url: str,
+    content_type: str,
+    size: int | None,
+) -> dict[str, Any]:
+    return {
+        "bucket": bucket,
+        "object_path": object_path,
+        "objectPath": object_path,
+        "file_url": file_url,
+        "fileUrl": file_url,
+        "content_type": content_type,
+        "contentType": content_type,
+        "size": size,
+    }
+
+
+def _resumable_metadata(
+    *,
+    bucket: str,
+    object_path: str,
+    file_url: str,
+    upload_url: str | None,
+    content_type: str,
+    size: int | None,
+) -> dict[str, Any]:
+    payload = _storage_metadata(
+        bucket=bucket,
+        object_path=object_path,
+        file_url=file_url,
+        content_type=content_type,
+        size=size,
+    )
+    payload["upload_url"] = upload_url
+    payload["uploadUrl"] = upload_url
+    return payload
+
+
 @dataclass
 class LocalStorageService:
     """Filesystem-backed ctx.storage implementation used by local SDK dev."""
@@ -122,13 +163,13 @@ class LocalStorageService:
         target = self._target(object_path)
         target.parent.mkdir(parents=True, exist_ok=True)
         target.write_bytes(content)
-        return {
-            "bucket": "local",
-            "object_path": object_path,
-            "file_url": target.as_uri(),
-            "content_type": _content_type(filename, content_type),
-            "size": len(content),
-        }
+        return _storage_metadata(
+            bucket="local",
+            object_path=object_path,
+            file_url=target.as_uri(),
+            content_type=_content_type(filename, content_type),
+            size=len(content),
+        )
 
     async def upload_file_stream(
         self,
@@ -168,13 +209,13 @@ class LocalStorageService:
                 chunk_count=chunk_count,
                 state="complete",
             )
-            return {
-                "bucket": "local",
-                "object_path": object_path,
-                "file_url": target.as_uri(),
-                "content_type": _content_type(filename, content_type),
-                "size": 0,
-            }
+            return _storage_metadata(
+                bucket="local",
+                object_path=object_path,
+                file_url=target.as_uri(),
+                content_type=_content_type(filename, content_type),
+                size=0,
+            )
         with target.open("wb") as out:
             chunk_index = 0
             while True:
@@ -194,13 +235,13 @@ class LocalStorageService:
                 )
         if loaded != total:
             raise RuntimeError(f"storage upload incomplete: uploaded {loaded} of {total} bytes")
-        return {
-            "bucket": "local",
-            "object_path": object_path,
-            "file_url": target.as_uri(),
-            "content_type": _content_type(filename, content_type),
-            "size": loaded,
-        }
+        return _storage_metadata(
+            bucket="local",
+            object_path=object_path,
+            file_url=target.as_uri(),
+            content_type=_content_type(filename, content_type),
+            size=loaded,
+        )
 
     async def upload_file_path(
         self,
@@ -234,11 +275,11 @@ class LocalStorageService:
         key: str | None = None,
     ) -> dict[str, Any]:
         object_path = self.object_path(filename, key=key)
-        return {
-            "bucket": "local",
-            "object_path": object_path,
-            "file_url": self._target(object_path).as_uri(),
-            "upload_url": None,
-            "content_type": _content_type(filename, content_type),
-            "size": size,
-        }
+        return _resumable_metadata(
+            bucket="local",
+            object_path=object_path,
+            file_url=self._target(object_path).as_uri(),
+            upload_url=None,
+            content_type=_content_type(filename, content_type),
+            size=size,
+        )

package/docs/python-backend-sdk.md

@@ -1044,3 +1044,5 @@ async def create_note(
 
 This route stores app-owned data in the app database and writes a related file
 into Palette Data Rooms from the Python backend.
+
+Backend storage responses include both snake_case and camelCase aliases for object metadata (`object_path`/`objectPath`, `file_url`/`fileUrl`, `content_type`/`contentType`). The concrete values differ by environment, but the key contract is stable across local dev and hosted OS.

package/package.json

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