@riverbankcms/sdk 0.8.0 → 0.8.1

package/dist/cli/index.js

@@ -7,9 +7,9 @@ var fs6 = require('fs');
 var dotenv = require('dotenv');
 var commander = require('commander');
 var zod = require('zod');
-var prompts = require('prompts');
 var fs3 = require('fs/promises');
 var readline = require('readline');
+var prompts = require('prompts');
 var equal = require('fast-deep-equal');
 var os = require('os');
 var child_process = require('child_process');
@@ -41,9 +41,9 @@ function _interopNamespace(e) {
 
 var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
 var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
-var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
+var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var simpleGit__default = /*#__PURE__*/_interopDefault(simpleGit);
@@ -506,7 +506,11 @@ var uiSchema = zod.z.object({
   layout: zod.z.enum(["stack", "grid"]).optional(),
   columns: zod.z.number().int().min(2).max(4).optional(),
   // Entry picker configuration
-  contentTypeField: zod.z.string().optional()
+  contentTypeField: zod.z.string().optional(),
+  // Extras pattern: fields marked as extras are hidden behind a modal toggle
+  extras: zod.z.boolean().optional(),
+  // Render in block header instead of form body (used for section styles)
+  renderInHeader: zod.z.boolean().optional()
 }).partial();
 var baseFieldSchema = zod.z.object({
   id: zod.z.string().min(1, "Field id is required"),
@@ -1676,25 +1680,30 @@ function createButtonGroup(options = {}) {
       ui: { colSpan: 2 }
     }
   ];
-  const iconsGroup = {
-    id: "icons",
-    type: "group",
-    label: "Icons",
-    required: false,
-    ui: { preset: "disclosure", colSpan: 2 },
-    schema: {
-      fields: [
-        { id: "iconLeft", type: "media", label: "Left icon", required: false, mediaKinds: ["image"] },
-        { id: "iconRight", type: "media", label: "Right icon", required: false, mediaKinds: ["image"] }
-      ]
+  const iconFields = [
+    {
+      id: "iconLeft",
+      type: "media",
+      label: "Left icon",
+      required: false,
+      mediaKinds: ["image"],
+      ui: { extras: true }
+    },
+    {
+      id: "iconRight",
+      type: "media",
+      label: "Right icon",
+      required: false,
+      mediaKinds: ["image"],
+      ui: { extras: true }
     }
-  };
+  ];
   return {
     id: groupId,
     type: "group",
     label: groupLabel,
     ui: { layout: "grid", columns: 2, flattenInRepeater, hideLabel: !showGroupLabel },
-    schema: { fields: [...mainFields, iconsGroup] },
+    schema: { fields: [...mainFields, ...iconFields] },
     required: false
   };
 }
@@ -2990,6 +2999,10 @@ var BACKGROUND_POSITION_PRESETS = [
 BACKGROUND_POSITION_PRESETS.map((p) => p.value);
 
 // ../blocks/src/system/fields/background.ts
+var BACKGROUND_WIDGETS = {
+  COLOR: "backgroundColor",
+  GRADIENT: "backgroundGradient"
+};
 function createBackgroundField(options = {}) {
   const {
     id = "background",
@@ -3015,8 +3028,7 @@ function createBackgroundField(options = {}) {
           required: false,
           multiline: false,
           ui: {
-            // Use BackgroundColorWidget via widget override
-            widget: "backgroundColor"
+            widget: BACKGROUND_WIDGETS.COLOR
           }
         }
       ]
@@ -3033,11 +3045,11 @@ function createBackgroundField(options = {}) {
           id: "gradient",
           type: "text",
           label: "Gradient",
-          description: "CSS gradient value (e.g., linear-gradient(to right, #ff0000, #00ff00)).",
+          description: "Select a gradient from theme presets.",
           required: false,
-          multiline: true,
+          multiline: false,
           ui: {
-            placeholder: "linear-gradient(to right, #ff0000, #00ff00)"
+            widget: BACKGROUND_WIDGETS.GRADIENT
           }
         }
       ]
@@ -3096,7 +3108,7 @@ function createBackgroundField(options = {}) {
         id: "position",
         type: "presetOrCustom",
         label: "Position",
-        description: 'Anchor point for the image. Relevant for "Fill" and "Custom size" options.',
+        description: 'Anchor point for scaled images. For "Fill" mode, the image focus point (if set) takes precedence.',
         required: false,
         presets: [...BACKGROUND_POSITION_PRESETS],
         customInput: {
@@ -3187,6 +3199,8 @@ function sectionStylesField(options = {}) {
     required: false,
     schema: { fields: fields4 },
     ui: {
+      // Render in block header instead of form body
+      renderInHeader: true,
       modalConfig: {
         buttonLabel: label,
         description: "Configure background and spacing for this section.",
@@ -5643,111 +5657,6 @@ var riverbankSiteConfigSchema = zod.z.object({
 
 // src/cli/push-config.ts
 init_load_config();
-async function pushToDashboard(dashboardUrl, siteId, apiKey, config3) {
-  const pushUrl = `${dashboardUrl}/api/sites/${siteId}/sdk-config`;
-  console.log(`Pushing config to ${pushUrl}...`);
-  let response;
-  try {
-    response = await fetch(pushUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({ config: config3 }),
-      signal: AbortSignal.timeout(3e4)
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to connect to dashboard: ${message}`);
-  }
-  if (!response.ok) {
-    let errorMessage = `Dashboard returned ${response.status}`;
-    try {
-      const errorBody = await response.json();
-      if (errorBody.error) {
-        errorMessage = errorBody.error;
-        if (errorBody.details) {
-          errorMessage += ":\n" + errorBody.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
-        }
-      }
-    } catch {
-    }
-    throw new Error(errorMessage);
-  }
-}
-async function pushConfigAction(options) {
-  try {
-    const rawConfig = await loadConfigFile(options.config);
-    console.log("Validating config...");
-    const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
-    if (!parseResult.success) {
-      console.error("Invalid config:");
-      for (const issue of parseResult.error.issues) {
-        console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
-      }
-      process.exit(1);
-    }
-    const conflicts = validateFieldIdConflicts(parseResult.data.blockFieldExtensions);
-    if (conflicts.length > 0) {
-      console.error("Field ID conflicts detected in blockFieldExtensions:");
-      for (const conflict of conflicts) {
-        console.error(`  - ${conflict.message}`);
-      }
-      process.exit(1);
-    }
-    const { siteId } = parseResult.data;
-    const apiKey = resolveManagementApiKey(options.apiKey, options.isRemote);
-    await pushToDashboard(options.dashboard, siteId, apiKey, parseResult.data);
-    console.log("Config pushed successfully!");
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-function resolveDashboardUrl(cliOption, isRemote) {
-  const envVar = isRemote ? "RIVERBANK_REMOTE_DASHBOARD_URL" : "RIVERBANK_LOCAL_DASHBOARD_URL";
-  const url = cliOption || process.env[envVar];
-  if (!url) {
-    console.error("Error: Dashboard URL is required.");
-    console.error(`Provide --dashboard <url> or set ${envVar} environment variable.`);
-    process.exit(1);
-  }
-  return url;
-}
-function resolveManagementApiKey(cliOption, isRemote) {
-  const envVar = isRemote ? "RIVERBANK_REMOTE_MGMT_API_KEY" : "RIVERBANK_LOCAL_MGMT_API_KEY";
-  const apiKey = cliOption || process.env[envVar];
-  if (!apiKey) {
-    console.error("Error: Management API key is required.");
-    console.error(`Provide --api-key <key> or set ${envVar} environment variable.`);
-    process.exit(1);
-  }
-  if (!apiKey.startsWith("bld_mgmt_sk_")) {
-    console.error(`Error: Invalid management API key format for ${envVar}.`);
-    console.error("Expected key starting with bld_mgmt_sk_.");
-    process.exit(1);
-  }
-  return apiKey;
-}
-var pushConfigCommand = new commander.Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", "Path to config file (default: ./riverbank.config.ts)").addHelpText("after", `
-Description:
-  Syncs your local riverbank.config.ts to the CMS dashboard, including:
-  - Custom blocks
-  - Block field extensions
-  - Block field options
-  - Content types, pages, entries, and navigation
-
-Examples:
-  $ npx riverbankcms push-config
-  $ npx riverbankcms push-config --api-key bld_mgmt_sk_... --dashboard https://www.riverbankcms.com
-  $ npx riverbankcms push-config --config ./src/riverbank.config.ts
-`).action((options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  const isRemote = globalOpts.remote ?? false;
-  const dashboard = resolveDashboardUrl(options.dashboard, isRemote);
-  return pushConfigAction({ ...options, dashboard, isRemote });
-});
 
 // src/client/management/http.ts
 var ManagementApiError = class extends Error {
@@ -5759,6 +5668,9 @@ var ManagementApiError = class extends Error {
     this.statusCode = statusCode;
   }
 };
+function is404Error(error) {
+  return error instanceof ManagementApiError && error.statusCode === 404;
+}
 function createHttpClient(config3) {
   const baseUrl = `${config3.dashboardUrl}/api/sdk/${config3.siteId}`;
   const timeout = config3.timeout ?? 3e4;
@@ -5864,7 +5776,7 @@ function createEntryOperations(http) {
           `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5906,7 +5818,7 @@ function createPageOperations(http) {
           `/pages/${encodeURIComponent(identifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5939,7 +5851,7 @@ function createBlockOperations(http) {
           `/pages/${encodeURIComponent(pageIdentifier)}/blocks/${encodeURIComponent(blockIdentifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5978,7 +5890,7 @@ function createNavigationOperations(http) {
           `/navigation/${encodeURIComponent(name)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -6047,6 +5959,9 @@ function createPullOperations(http) {
           truncationMessage: entriesResult?.meta?.truncationMessage
         }
       };
+    },
+    async siteInfo() {
+      return http.get("/pull/site-info");
     }
   };
 }
@@ -6069,6 +5984,122 @@ function createIdentifiersOperations(http) {
   };
 }
 
+// src/client/management/media.ts
+function createMediaOperations(config3) {
+  const baseUrl = `${config3.dashboardUrl}/api/sdk/${config3.siteId}`;
+  const timeout = config3.timeout ?? 6e4;
+  async function formDataRequest(path13, formData) {
+    const url = `${baseUrl}${path13}`;
+    const headers = {
+      "Authorization": `Bearer ${config3.managementApiKey}`
+      // Note: Don't set Content-Type - let fetch set it with boundary
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: formData,
+        signal: AbortSignal.timeout(timeout)
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new ManagementApiError(
+          `Request timed out after ${timeout}ms`,
+          "sdk:timeout",
+          void 0,
+          void 0
+        );
+      }
+      throw new ManagementApiError(
+        error instanceof Error ? error.message : "Network request failed",
+        "sdk:network-error",
+        void 0,
+        void 0
+      );
+    }
+    const json = await response.json();
+    if (!response.ok || !json.success) {
+      if (json.error) {
+        throw new ManagementApiError(
+          json.error.message,
+          json.error.code,
+          json.error.details,
+          response.status
+        );
+      }
+      throw new ManagementApiError(
+        `Request failed with status ${response.status}`,
+        "sdk:http-error",
+        void 0,
+        response.status
+      );
+    }
+    return json.data;
+  }
+  async function jsonRequest(path13, body) {
+    const url = `${baseUrl}${path13}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${config3.managementApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new ManagementApiError(
+          "Request timed out after 30000ms",
+          "sdk:timeout",
+          void 0,
+          void 0
+        );
+      }
+      throw new ManagementApiError(
+        error instanceof Error ? error.message : "Network request failed",
+        "sdk:network-error",
+        void 0,
+        void 0
+      );
+    }
+    const json = await response.json();
+    if (!response.ok || !json.success) {
+      if (json.error) {
+        throw new ManagementApiError(
+          json.error.message,
+          json.error.code,
+          json.error.details,
+          response.status
+        );
+      }
+      throw new ManagementApiError(
+        `Request failed with status ${response.status}`,
+        "sdk:http-error",
+        void 0,
+        response.status
+      );
+    }
+    return json.data;
+  }
+  return {
+    async upload(file) {
+      const formData = new FormData();
+      const blob = new Blob([new Uint8Array(file.data)], { type: file.contentType });
+      formData.append("file", blob, file.filename);
+      formData.append("storagePath", file.storagePath);
+      return formDataRequest("/media/upload", formData);
+    },
+    async exists(storagePath) {
+      const result = await jsonRequest("/media/exists", { storagePath });
+      return result.exists;
+    }
+  };
+}
+
 // src/client/management/index.ts
 function createManagementClient(config3) {
   if (!config3.dashboardUrl) {
@@ -6100,11 +6131,16 @@ function createManagementClient(config3) {
     settings: createSettingsOperations(http),
     pull: createPullOperations(http),
     preview: createPreviewOperations(http),
-    identifiers: createIdentifiersOperations(http)
+    identifiers: createIdentifiersOperations(http),
+    media: createMediaOperations(config3)
   };
 }
 
 // src/cli/env.ts
+function getEnvVarName(key, remote) {
+  const target = remote ? "REMOTE" : "LOCAL";
+  return `RIVERBANK_${target}_${key}`;
+}
 function getEnvPrefix(target) {
   return target === "remote" ? "RIVERBANK_REMOTE" : "RIVERBANK_LOCAL";
 }
@@ -6115,12 +6151,16 @@ function requireEnv(name) {
   }
   return value;
 }
+function getEnv(name, fallback) {
+  return process.env[name] ?? fallback;
+}
 function loadEnvironment(remote) {
   const target = remote ? "remote" : "local";
   const prefix = getEnvPrefix(target);
   const siteId = requireEnv(`${prefix}_SITE_ID`);
   const dashboardUrl = requireEnv(`${prefix}_DASHBOARD_URL`);
   const managementApiKey = requireEnv(`${prefix}_MGMT_API_KEY`);
+  const supabaseUrl = getEnv(`${prefix}_SUPABASE_URL`);
   if (!managementApiKey.startsWith("bld_mgmt_sk_")) {
     throw new Error(
       `Invalid management API key format for ${prefix}_MGMT_API_KEY. Expected key starting with bld_mgmt_sk_`
@@ -6133,10 +6173,20 @@ function loadEnvironment(remote) {
       `Invalid dashboard URL in ${prefix}_DASHBOARD_URL: ${dashboardUrl}. Expected format: http://localhost:4000 or https://dashboard.example.com`
     );
   }
+  if (supabaseUrl) {
+    try {
+      new URL(supabaseUrl);
+    } catch {
+      throw new Error(
+        `Invalid Supabase URL in ${prefix}_SUPABASE_URL: ${supabaseUrl}. Expected format: http://127.0.0.1:54321 or https://xxx.supabase.co`
+      );
+    }
+  }
   return {
     siteId,
     dashboardUrl,
-    managementApiKey
+    managementApiKey,
+    supabaseUrl
   };
 }
 
@@ -6513,6 +6563,112 @@ function createListCommand(config3) {
   );
 }
 
+// src/cli/push-config.ts
+async function pushToDashboard(output, dashboardUrl, siteId, apiKey, config3) {
+  const pushUrl = `${dashboardUrl}/api/sites/${siteId}/sdk-config`;
+  output.info(`Pushing config to ${pushUrl}...`);
+  let response;
+  try {
+    response = await fetch(pushUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ config: config3 }),
+      signal: AbortSignal.timeout(3e4)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to connect to dashboard: ${message}`);
+  }
+  if (!response.ok) {
+    let errorMessage = `Dashboard returned ${response.status}`;
+    try {
+      const errorBody = await response.json();
+      if (errorBody.error) {
+        errorMessage = errorBody.error;
+        if (errorBody.details) {
+          errorMessage += ":\n" + errorBody.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
+        }
+      }
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+}
+async function pushConfigAction(output, options) {
+  try {
+    const rawConfig = await loadConfigFile(options.config);
+    output.info("Validating config...");
+    const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
+    if (!parseResult.success) {
+      output.error("Invalid config", {
+        issues: parseResult.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
+    }
+    const conflicts = validateFieldIdConflicts(parseResult.data.blockFieldExtensions);
+    if (conflicts.length > 0) {
+      output.error("Field ID conflicts detected in blockFieldExtensions", {
+        conflicts: conflicts.map((c) => c.message)
+      });
+    }
+    const { siteId } = parseResult.data;
+    const apiKey = resolveManagementApiKey(output, options.apiKey, options.isRemote);
+    await pushToDashboard(output, options.dashboard, siteId, apiKey, parseResult.data);
+    output.success("Config pushed successfully!");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    output.error(message);
+  }
+}
+function resolveDashboardUrl(output, cliOption, isRemote) {
+  const envVar = getEnvVarName("DASHBOARD_URL", isRemote);
+  const url = cliOption || process.env[envVar];
+  if (!url) {
+    output.error("Dashboard URL is required", {
+      suggestion: `Provide --dashboard <url> or set ${envVar} environment variable.`
+    });
+  }
+  return url;
+}
+function resolveManagementApiKey(output, cliOption, isRemote) {
+  const envVar = getEnvVarName("MGMT_API_KEY", isRemote);
+  const apiKey = cliOption || process.env[envVar];
+  if (!apiKey) {
+    output.error("Management API key is required", {
+      suggestion: `Provide --api-key <key> or set ${envVar} environment variable.`
+    });
+  }
+  if (!apiKey.startsWith("bld_mgmt_sk_")) {
+    output.error("Invalid management API key format", {
+      expected: "Key starting with bld_mgmt_sk_",
+      suggestion: `Check your ${envVar} environment variable.`
+    });
+  }
+  return apiKey;
+}
+var pushConfigCommand = new commander.Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", "Path to config file (default: ./riverbank.config.ts)").addHelpText("after", `
+Description:
+  Syncs your local riverbank.config.ts to the CMS dashboard, including:
+  - Custom blocks
+  - Block field extensions
+  - Block field options
+  - Content types, pages, entries, and navigation
+
+Examples:
+  $ npx riverbankcms push-config
+  $ npx riverbankcms push-config --api-key bld_mgmt_sk_... --dashboard https://www.riverbankcms.com
+  $ npx riverbankcms push-config --config ./src/riverbank.config.ts
+`).action((options, command) => {
+  const { output, isRemote } = getOutputContext(command);
+  const dashboard = resolveDashboardUrl(output, options.dashboard, isRemote);
+  return pushConfigAction(output, { ...options, dashboard, isRemote });
+});
+
 // src/cli/sync/mapper.ts
 function stripNavigationItemIds(items) {
   return items.map((item) => {
@@ -6616,6 +6772,53 @@ async function writeSettings(contentDir, pulledSettings) {
   await writeJsonFile(filePath, pulledSettings.settings);
   return filePath;
 }
+async function updateMetadataAfterPush(contentDir, remoteContent) {
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  await ensureDir(metaDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [contentType, entries] of Object.entries(remoteContent.entries)) {
+    const metaPath = path9__namespace.join(metaDir, `${contentType}.json`);
+    const entriesMeta = {};
+    for (const entry of entries) {
+      entriesMeta[entry.identifier] = {
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      entries: entriesMeta
+    });
+  }
+  if (remoteContent.pages.length > 0) {
+    const metaPath = path9__namespace.join(metaDir, "pages.json");
+    const pagesMeta = {};
+    for (const page of remoteContent.pages) {
+      pagesMeta[page.identifier] = {
+        createdAt: page.createdAt,
+        updatedAt: page.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      pages: pagesMeta
+    });
+  }
+  if (remoteContent.navigation.length > 0) {
+    const metaPath = path9__namespace.join(metaDir, "navigation.json");
+    const menusMeta = {};
+    for (const menu of remoteContent.navigation) {
+      menusMeta[menu.name] = {
+        createdAt: menu.createdAt,
+        updatedAt: menu.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      menus: menusMeta
+    });
+  }
+}
 async function fileExists(filePath) {
   try {
     await fs3__namespace.access(filePath);
@@ -6764,6 +6967,107 @@ async function readNavigationMeta(contentDir) {
   }
 }
 
+// src/cli/sync/media.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  // 1 second
+  maxDelayMs: 1e4
+  // 10 seconds
+};
+function sleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+function getBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+  const jitter = exponentialDelay * (0.75 + Math.random() * 0.5);
+  return Math.min(jitter, maxDelayMs);
+}
+async function withRetry(fn, options = {}) {
+  const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULT_RETRY_CONFIG, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        const delay = getBackoffDelay(attempt, baseDelayMs, maxDelayMs);
+        options.onRetry?.(attempt + 1, lastError);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function extractMediaPaths(data) {
+  const paths = /* @__PURE__ */ new Set();
+  function walk(value) {
+    if (value === null || value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if (typeof obj.storagePath === "string" && obj.storagePath) {
+        paths.add(obj.storagePath);
+      }
+      for (const key of Object.keys(obj)) {
+        walk(obj[key]);
+      }
+    }
+  }
+  walk(data);
+  return paths;
+}
+function buildStorageUrl(supabaseUrl, relativePath, siteId, bucket = "media") {
+  const baseUrl = supabaseUrl.replace(/\/$/, "");
+  const fullPath = `sites/${siteId}/${relativePath}`;
+  return `${baseUrl}/storage/v1/object/public/${bucket}/${fullPath}`;
+}
+async function downloadMedia(url, options) {
+  try {
+    return await withRetry(
+      async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            throw new DownloadError(`HTTP ${response.status}`, response.status, false);
+          }
+          throw new DownloadError(`HTTP ${response.status}`, response.status, true);
+        }
+        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+        const arrayBuffer = await response.arrayBuffer();
+        const data = Buffer.from(arrayBuffer);
+        return { data, contentType };
+      },
+      {
+        maxRetries: options?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+        onRetry: (attempt, error) => {
+          console.warn(`[media-sync] Retry ${attempt} for ${url}: ${error.message}`);
+        }
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[media-sync] Download failed after retries: ${url} - ${message}`);
+    return null;
+  }
+}
+var DownloadError = class extends Error {
+  constructor(message, status, retryable) {
+    super(message);
+    this.status = status;
+    this.retryable = retryable;
+    this.name = "DownloadError";
+  }
+};
+
 // src/cli/commands/pull.ts
 var DEFAULT_PAGE_LIMIT = 500;
 async function pullEntriesWithPagination(client, contentType, output) {
@@ -6848,21 +7152,105 @@ async function fetchAllContentPaginated(client, contentTypes, output) {
     meta: { pulledAt: (/* @__PURE__ */ new Date()).toISOString(), entries: allMeta }
   };
 }
-var pullCommand = new commander.Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").addHelpText("after", `
+async function syncMediaFiles(content, sourceSupabaseUrl, sourceSiteId, targetSiteId, targetClient, output) {
+  const mediaPaths = extractMediaPaths(content);
+  if (mediaPaths.size === 0) {
+    output.info("No media files found in content");
+    return;
+  }
+  output.info(`Found ${mediaPaths.size} media files to sync`);
+  let synced = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const relativePath of mediaPaths) {
+    const filename = relativePath.split("/").pop() ?? "file";
+    const targetPath = `sites/${targetSiteId}/${relativePath}`;
+    try {
+      const exists = await targetClient.media.exists(targetPath);
+      if (exists) {
+        skipped++;
+        continue;
+      }
+    } catch (error) {
+      if (process.env.DEBUG) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.warn(`[media-sync] Could not check if ${filename} exists: ${message}`);
+      }
+    }
+    const url = buildStorageUrl(sourceSupabaseUrl, relativePath, sourceSiteId);
+    const downloaded = await downloadMedia(url);
+    if (!downloaded) {
+      output.warn(`  Failed to download: ${filename}`);
+      failed++;
+      continue;
+    }
+    try {
+      await targetClient.media.upload({
+        data: downloaded.data,
+        filename,
+        contentType: downloaded.contentType,
+        storagePath: targetPath
+      });
+      synced++;
+    } catch (error) {
+      output.warn(`  Failed to upload: ${filename}`);
+      failed++;
+    }
+  }
+  output.info(`Media sync: ${synced} synced, ${skipped} skipped (already exist), ${failed} failed`);
+}
+var pullCommand = new commander.Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").option("--sync-media", "Sync media files from source to target environment").addHelpText("after", `
 Examples:
   $ riverbankcms pull                         # Pull all content
   $ riverbankcms pull --remote                # Pull from production
+  $ riverbankcms pull --remote --sync-media   # Pull from production and sync media to local
   $ riverbankcms pull entries                 # Pull all entries
   $ riverbankcms pull entries blog-post       # Pull specific content type
   $ riverbankcms pull pages                   # Pull pages with blocks
   $ riverbankcms pull navigation              # Pull navigation menus
   $ riverbankcms pull settings                # Pull site settings
   $ riverbankcms pull --output ./src/content  # Custom output directory
+
+Media Sync:
+  When using --sync-media, media files are:
+  1. Downloaded from the source environment's Supabase storage
+  2. Uploaded to the target environment via the management API
+
+  The storage URL is automatically fetched from the source CMS API.
+  No additional environment variables are required beyond the standard
+  RIVERBANK_*_DASHBOARD_URL, RIVERBANK_*_SITE_ID, and RIVERBANK_*_MGMT_API_KEY.
 `).action(
   withErrorHandling(
     async (scope, type, options, command) => {
-      const { output, client } = createCommandContext(command);
+      const { output, client, isRemote } = createCommandContext(command);
       const contentDir = path9__namespace.resolve(options.output ?? "./content");
+      let targetClient = null;
+      let sourceSupabaseUrl = null;
+      let sourceSiteId = null;
+      let targetSiteId = null;
+      if (options.syncMedia) {
+        const sourceEnv = loadEnvironment(isRemote);
+        const targetEnv = loadEnvironment(!isRemote);
+        output.info("Fetching storage configuration from source...");
+        try {
+          const siteInfo = await client.pull.siteInfo();
+          sourceSupabaseUrl = siteInfo.supabaseUrl;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          output.error(`Failed to get storage configuration from source: ${message}`, {
+            suggestion: "Ensure the source CMS is running and accessible"
+          });
+          return;
+        }
+        sourceSiteId = sourceEnv.siteId;
+        targetSiteId = targetEnv.siteId;
+        targetClient = createManagementClient({
+          dashboardUrl: targetEnv.dashboardUrl,
+          managementApiKey: targetEnv.managementApiKey,
+          siteId: targetEnv.siteId
+        });
+        output.info(`Media sync enabled: ${isRemote ? "remote" : "local"} -> ${isRemote ? "local" : "remote"}`);
+      }
       if (await contentDirExists(contentDir) && !options.force && !options.yes) {
         if (!process.stdin.isTTY) {
           output.error("Content directory already exists and --yes not specified", {
@@ -6945,6 +7333,17 @@ Examples:
             const contentTypes = Object.keys(result.entries);
             result = await fetchAllContentPaginated(client, contentTypes, output);
           }
+          if (targetClient && sourceSupabaseUrl && sourceSiteId && targetSiteId) {
+            output.info("Syncing media files...");
+            await syncMediaFiles(
+              result,
+              sourceSupabaseUrl,
+              sourceSiteId,
+              targetSiteId,
+              targetClient,
+              output
+            );
+          }
           const { totalCount: totalEntries } = await writeAllEntries(
             contentDir,
             result.entries,
@@ -7943,6 +8342,43 @@ Safety:
       output
     );
     reportSyncResults(output, result, result.errors.length > 0);
+    if (result.errors.length === 0) {
+      try {
+        output.info("Updating local metadata...");
+        const freshRemote = await client.pull.all();
+        const entriesForMeta = {};
+        if (freshRemote.meta.entries) {
+          for (const [key, meta] of Object.entries(freshRemote.meta.entries)) {
+            const [contentType, identifier] = key.split(":");
+            if (contentType && identifier) {
+              if (!entriesForMeta[contentType]) {
+                entriesForMeta[contentType] = [];
+              }
+              entriesForMeta[contentType].push({
+                identifier,
+                updatedAt: meta.updatedAt,
+                createdAt: meta.createdAt
+              });
+            }
+          }
+        }
+        await updateMetadataAfterPush(contentDir, {
+          entries: entriesForMeta,
+          pages: freshRemote.pages.map((p) => ({
+            identifier: p.identifier,
+            updatedAt: p.updatedAt,
+            createdAt: p.createdAt
+          })),
+          navigation: freshRemote.navigation.map((n) => ({
+            name: n.name,
+            updatedAt: n.updatedAt,
+            createdAt: n.createdAt
+          }))
+        });
+      } catch (metaError) {
+        output.warn('Push succeeded but metadata update failed. Run "pull" to sync metadata.');
+      }
+    }
   } catch (error) {
     handleCommandError(error, output);
   }
@@ -11042,7 +11478,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.8.0";
+var SDK_VERSION = "0.8.1";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -11189,7 +11625,7 @@ var RiverbankApiError = class _RiverbankApiError extends Error {
 };
 
 // src/client/resilience.ts
-var DEFAULT_RETRY_CONFIG = {
+var DEFAULT_RETRY_CONFIG2 = {
   maxAttempts: 3,
   baseDelayMs: 200,
   maxDelayMs: 2e3,
@@ -11272,9 +11708,9 @@ function isTransientError(error) {
   return true;
 }
 function calculateBackoff(attempt, config3) {
-  const baseDelayMs = config3.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs;
-  const maxDelayMs = config3.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs;
-  const jitter = config3.jitter ?? DEFAULT_RETRY_CONFIG.jitter;
+  const baseDelayMs = config3.baseDelayMs ?? DEFAULT_RETRY_CONFIG2.baseDelayMs;
+  const maxDelayMs = config3.maxDelayMs ?? DEFAULT_RETRY_CONFIG2.maxDelayMs;
+  const jitter = config3.jitter ?? DEFAULT_RETRY_CONFIG2.jitter;
   const exponential = baseDelayMs * Math.pow(2, attempt - 1);
   const capped = Math.min(exponential, maxDelayMs);
   if (jitter === "full") {
@@ -11378,7 +11814,7 @@ var CircuitBreaker = class {
   }
 };
 async function fetchWithTimeoutAndRetry(fetcher, config3) {
-  const maxAttempts = config3.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
+  const maxAttempts = config3.maxAttempts ?? DEFAULT_RETRY_CONFIG2.maxAttempts;
   const requestTimeoutMs = config3.requestTimeoutMs ?? 8e3;
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -11399,7 +11835,7 @@ async function fetchWithTimeoutAndRetry(fetcher, config3) {
       }
       if (attempt < maxAttempts) {
         const delay = getRetryDelay(error, attempt, config3);
-        await sleep(delay);
+        await sleep2(delay);
       }
     }
   }
@@ -11430,7 +11866,7 @@ function getRetryDelay(error, attempt, config3) {
   }
   return calculateBackoff(attempt, config3);
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 var CircuitOpenError = class extends Error {
@@ -11565,10 +12001,10 @@ function createRiverbankClient(config3) {
   const staleTtlMs = (config3.resilience?.staleTtlSec ?? 300) * 1e3;
   const requestTimeoutMs = config3.resilience?.requestTimeoutMs ?? (typeof window !== "undefined" ? DEFAULT_BROWSER_TIMEOUT_MS : DEFAULT_SERVER_TIMEOUT_MS);
   const retryConfig = {
-    maxAttempts: config3.resilience?.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts,
-    baseDelayMs: config3.resilience?.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
-    maxDelayMs: config3.resilience?.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
-    jitter: config3.resilience?.retry?.jitter ?? DEFAULT_RETRY_CONFIG.jitter,
+    maxAttempts: config3.resilience?.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG2.maxAttempts,
+    baseDelayMs: config3.resilience?.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG2.baseDelayMs,
+    maxDelayMs: config3.resilience?.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG2.maxDelayMs,
+    jitter: config3.resilience?.retry?.jitter ?? DEFAULT_RETRY_CONFIG2.jitter,
     retryOn: config3.resilience?.retry?.retryOn
   };
   const circuitBreakerConfig = {