storyblok 4.13.0 → 4.14.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import 'dotenv/config';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { resolve, dirname, isAbsolute, relative as relative$1, join as join$1 } from 'pathe';
 import { existsSync, mkdirSync, appendFileSync, writeFileSync, readdirSync, unlinkSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -8,10 +8,10 @@ import { loadConfig as loadConfig$1, SUPPORTED_EXTENSIONS } from 'c12';
 import chalk from 'chalk';
 import { readPackageUp } from 'read-package-up';
 import { Command } from 'commander';
-import path, { join, resolve as resolve$1, parse, dirname as dirname$1, extname, relative } from 'node:path';
+import path, { join, resolve as resolve$1, parse, dirname as dirname$1, extname, relative, basename } from 'node:path';
 import { MultiBar, Presets } from 'cli-progress';
 import { Spinner } from '@topcli/spinner';
-import fs, { mkdir, writeFile, readFile as readFile$1, appendFile, access, readdir } from 'node:fs/promises';
+import fs, { mkdir, writeFile, readFile as readFile$1, appendFile, access, constants, readdir, unlink, stat } from 'node:fs/promises';
 import filenamify from 'filenamify';
 import { select, password, input, confirm } from '@inquirer/prompts';
 import { ManagementApiClient } from '@storyblok/management-api-client';
@@ -24,6 +24,10 @@ import { hash } from 'ohash';
 import { compile } from 'json-schema-to-typescript';
 import open from 'open';
 import { Octokit } from 'octokit';
+import { pipeline as pipeline$1 } from 'node:stream/promises';
+import { Buffer } from 'node:buffer';
+import Storyblok from 'storyblok-js-client';
+import { createHash } from 'node:crypto';
 
 const commands = {
   LOGIN: "login",
@@ -37,7 +41,9 @@ const commands = {
   DATASOURCES: "datasources",
   CREATE: "create",
   LOGS: "logs",
-  REPORTS: "reports"
+  REPORTS: "reports",
+  ASSETS: "assets",
+  STORIES: "stories"
 };
 const colorPalette = {
   PRIMARY: "#8d60ff",
@@ -55,7 +61,9 @@ const colorPalette = {
   PRESETS: "#a855f7",
   DATASOURCES: "#4ade80",
   LOGS: "#4ade80",
-  REPORTS: "#4ade80"
+  REPORTS: "#4ade80",
+  ASSETS: "#f97316",
+  STORIES: "#a185ff"
 };
 const regions = {
   EU: "eu",
@@ -96,10 +104,12 @@ const regionNames = {
   SB_Agent_Version: process.env.npm_package_version || "4.x"
 });
 const directories = {
-  log: "logs",
-  report: "reports",
+  assets: "assets",
   components: "components",
-  datasources: "datasources"
+  datasources: "datasources",
+  logs: "logs",
+  reports: "reports",
+  stories: "stories"
 };
 
 function isPlainObject(value) {
@@ -600,7 +610,17 @@ const API_ACTIONS = {
   update_component_preset: "Failed to update component preset",
   pull_stories: "Failed to pull stories",
   pull_story: "Failed to pull story",
+  create_story: "Failed to create story",
   update_story: "Failed to update story",
+  pull_asset: "Failed to pull asset",
+  pull_assets: "Failed to pull assets",
+  pull_asset_folder: "Failed to pull asset folder",
+  pull_asset_folders: "Failed to pull asset folders",
+  push_asset_folder: "Failed to push asset folder",
+  push_asset_sign: "Failed to sign asset upload",
+  push_asset_upload: "Failed to upload asset",
+  push_asset_finish: "Failed to finish asset upload",
+  push_asset_update: "Failed to update asset",
   pull_datasources: "Failed to pull datasources",
   push_datasource: "Failed to push datasource",
   update_datasource: "Failed to update datasource",
@@ -860,7 +880,7 @@ function handleVerboseError(error) {
     konsola.error(`Unexpected Error`, error);
   }
 }
-function handleError(error, verbose = false) {
+function handleError(error, verbose = false, context) {
   if (error instanceof APIError || error instanceof FileSystemError) {
     const messageStack = error.messageStack;
     messageStack.forEach((message, index) => {
@@ -883,7 +903,10 @@ function handleError(error, verbose = false) {
   if (!process.env.VITEST) {
     console.log("");
   }
-  getLogger().error(error.message, { error, errorCode: "code" in error ? String(error.code) : "UNKNOWN_ERROR" });
+  getLogger().error(error.message, { error, errorCode: "code" in error ? String(error.code) : "UNKNOWN_ERROR", context });
+}
+function logOnlyError(error, context) {
+  getLogger().error(error.message, { error, errorCode: "code" in error ? String(error.code) : "UNKNOWN_ERROR", context });
 }
 
 function requireAuthentication(state, verbose = false) {
@@ -1148,19 +1171,22 @@ const saveToFileSync = (filePath, data, options) => {
   }
 };
 const appendToFile = async (filePath, data, options) => {
-  const resolvedPath = parse(filePath).dir;
-  try {
-    await mkdir(resolvedPath, { recursive: true });
-  } catch (mkdirError) {
-    handleFileSystemError("mkdir", mkdirError);
-    return;
-  }
-  try {
-    const dataWithNewline = data.endsWith("\n") ? data : `${data}
+  const dataWithNewline = data.endsWith("\n") ? data : `${data}
 `;
+  try {
     await appendFile(filePath, dataWithNewline, options);
-  } catch (writeError) {
-    handleFileSystemError("write", writeError);
+  } catch (maybeError) {
+    const error = toError(maybeError);
+    if ("code" in error && error.code === "ENOENT") {
+      const dir = parse(filePath).dir;
+      await mkdir(dir, { recursive: true });
+      await appendFile(filePath, dataWithNewline, options);
+    } else {
+      handleFileSystemError(
+        "syscall" in error && error.syscall === "mkdir" ? "mkdir" : "write",
+        error
+      );
+    }
   }
 };
 const appendToFileSync = (filePath, data, options) => {
@@ -1187,6 +1213,30 @@ const readFile = async (filePath) => {
     return "";
   }
 };
+const loadManifest = async (manifestFile) => {
+  return readFile$1(manifestFile, "utf8").then((manifest) => manifest.split("\n").filter(Boolean).map((entry) => JSON.parse(entry))).catch((error) => {
+    if (error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+};
+const saveManifest = async (manifestFile, entries) => {
+  const content = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  await saveToFile(manifestFile, content ? `${content}
+` : "");
+};
+const deduplicateManifest = async (manifestFile) => {
+  const entries = await loadManifest(manifestFile);
+  if (entries.length === 0) {
+    return;
+  }
+  const uniqueEntries = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    uniqueEntries.set(entry.old_id, entry);
+  }
+  await saveManifest(manifestFile, Array.from(uniqueEntries.values()));
+};
 const resolvePath = (path, folder) => {
   const basePath = path ?? DEFAULT_STORAGE_DIR;
   return resolve$1(process.cwd(), basePath, folder);
@@ -1205,6 +1255,15 @@ const sanitizeFilename = (filename) => {
     replacement: "_"
   });
 };
+async function readDirectory(directoryPath) {
+  try {
+    const files = await readdir(directoryPath);
+    return files;
+  } catch (maybeError) {
+    handleFileSystemError("read", toError(maybeError));
+    return [];
+  }
+}
 async function readJsonFile(filePath) {
   try {
     const content = (await readFile(filePath)).toString();
@@ -1218,7 +1277,15 @@ async function readJsonFile(filePath) {
   }
 }
 function importModule(filePath) {
-  return import(`file://${filePath}`);
+  return import(pathToFileURL(filePath).href);
+}
+async function fileExists(path) {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 const REPORT_STATUS = {
@@ -1399,7 +1466,7 @@ class FileTransport {
           name: value.name,
           message: value.message,
           httpCode: value.code,
-          httpStatusText: value.error?.response.statusText,
+          httpStatusText: value.error?.response?.statusText,
           stack: value.stack
         };
         continue;
@@ -1491,7 +1558,7 @@ class ConsoleTransport {
           name: value.name,
           message: value.message,
           httpCode: value.code,
-          httpStatusText: value.error?.response.statusText,
+          httpStatusText: value.error?.response?.statusText,
           stack: value.stack
         });
       }
@@ -1558,7 +1625,7 @@ function getProgram() {
       }
       if (resolvedConfig.log.file.enabled) {
         const logsPath = resolveCommandPath(
-          directories.log,
+          directories.logs,
           options.space,
           options.path
         );
@@ -1582,7 +1649,7 @@ function getProgram() {
       getUI({ enabled: resolvedConfig.ui.enabled });
       if (resolvedConfig.report.enabled) {
         const reportPath = resolveCommandPath(
-          directories.report,
+          directories.reports,
           options.space,
           options.path
         );
@@ -1629,21 +1696,25 @@ function configsAreEqual(config1, config2) {
 function mapiClient(options) {
   if (!instance && options) {
     instance = new ManagementApiClient(options);
-    instance.interceptors.request.use(async (request) => {
-      const limit = resolveLimiter();
-      await limit();
-      return request;
-    });
+    if (getActiveConfig().api.maxConcurrency > 0) {
+      instance.interceptors.request.use(async (request) => {
+        const limit = resolveLimiter();
+        await limit();
+        return request;
+      });
+    }
     storedConfig = options;
   } else if (!instance) {
     throw new Error("MAPI client not initialized. Call mapiClient with configuration first.");
   } else if (options && storedConfig && !configsAreEqual(options, storedConfig)) {
     instance = new ManagementApiClient(options);
-    instance.interceptors.request.use(async (request) => {
-      const limit = resolveLimiter();
-      await limit();
-      return request;
-    });
+    if (getActiveConfig().api.maxConcurrency > 0) {
+      instance.interceptors.request.use(async (request) => {
+        const limit = resolveLimiter();
+        await limit();
+        return request;
+      });
+    }
     storedConfig = options;
   }
   return instance;
@@ -1971,14 +2042,14 @@ async function performInteractiveLogin(options) {
   }
 }
 
-const program$h = getProgram();
+const program$j = getProgram();
 const allRegionsText = Object.values(regions).join(",");
-program$h.command(commands.LOGIN).description("Login to the Storyblok CLI").option("-t, --token <token>", "Token to login directly without questions, like for CI environments").option(
+program$j.command(commands.LOGIN).description("Login to the Storyblok CLI").option("-t, --token <token>", "Token to login directly without questions, like for CI environments").option(
   "-r, --region <region>",
   `The region you would like to work in. Please keep in mind that the region must match the region of your space. This region flag will be used for the other cli's commands. You can use the values: ${allRegionsText}.`
 ).action(async (options) => {
   konsola.title(`${commands.LOGIN}`, colorPalette.LOGIN);
-  const verbose = program$h.opts().verbose;
+  const verbose = program$j.opts().verbose;
   const { token, region } = options;
   const { state, updateSession, persistCredentials, initializeSession } = session();
   await initializeSession();
@@ -2037,10 +2108,10 @@ program$h.command(commands.LOGIN).description("Login to the Storyblok CLI").opti
   konsola.br();
 });
 
-const program$g = getProgram();
-program$g.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
+const program$i = getProgram();
+program$i.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
   konsola.title(`${commands.LOGOUT}`, colorPalette.LOGOUT);
-  const verbose = program$g.opts().verbose;
+  const verbose = program$i.opts().verbose;
   try {
     const { state, initializeSession } = session();
     await initializeSession();
@@ -2088,10 +2159,10 @@ async function openSignupInBrowser(url) {
   }
 }
 
-const program$f = getProgram();
-program$f.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
+const program$h = getProgram();
+program$h.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
   konsola.title(`${commands.SIGNUP}`, colorPalette.SIGNUP);
-  const verbose = program$f.opts().verbose;
+  const verbose = program$h.opts().verbose;
   const { state, initializeSession } = session();
   await initializeSession();
   if (state.isLoggedIn && !state.envLogin) {
@@ -2113,10 +2184,10 @@ program$f.command(commands.SIGNUP).description("Sign up for Storyblok").action(a
   konsola.br();
 });
 
-const program$e = getProgram();
-program$e.command(commands.USER).description("Get the current user").action(async () => {
+const program$g = getProgram();
+program$g.command(commands.USER).description("Get the current user").action(async () => {
   konsola.title(`${commands.USER}`, colorPalette.USER);
-  const verbose = program$e.opts().verbose;
+  const verbose = program$g.opts().verbose;
   const { state, initializeSession } = session();
   await initializeSession();
   if (!requireAuthentication(state)) {
@@ -2145,8 +2216,8 @@ program$e.command(commands.USER).description("Get the current user").action(asyn
   konsola.br();
 });
 
-const program$d = getProgram();
-const componentsCommand = program$d.command(commands.COMPONENTS).alias("comp").description(`Manage your space's block schema`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/components");
+const program$f = getProgram();
+const componentsCommand = program$f.command(commands.COMPONENTS).alias("comp").description(`Manage your space's block schema`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/components");
 
 const DEFAULT_COMPONENTS_FILENAME = "components";
 const DEFAULT_GROUPS_FILENAME = "groups";
@@ -2531,10 +2602,10 @@ async function readConsolidatedFiles$1(resolvedPath, suffix) {
   };
 }
 
-const program$c = getProgram();
+const program$e = getProgram();
 componentsCommand.command("pull [componentName]").option("-f, --filename <filename>", "custom name to be used in file(s) name instead of space id").option("--sf, --separate-files", "Argument to create a single file for each component").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. components.<suffix>.json)").description(`Download your space's components schema as json. Optionally specify a component name to pull a single component.`).action(async (componentName, options) => {
   konsola.title(`${commands.COMPONENTS}`, colorPalette.COMPONENTS, componentName ? `Pulling component ${componentName}...` : "Pulling components...");
-  const verbose = program$c.opts().verbose;
+  const verbose = program$e.opts().verbose;
   const { space, path } = componentsCommand.opts();
   const {
     separateFiles = false,
@@ -3576,10 +3647,10 @@ async function pushWithDependencyGraph(space, spaceState, maxConcurrency = getAc
   return results;
 }
 
-const program$b = getProgram();
+const program$d = getProgram();
 componentsCommand.command("push [componentName]").description(`Push your space's components schema as json`).option("-f, --from <from>", "source space id").option("--fi, --filter <filter>", "glob filter to apply to the components before pushing").option("--sf, --separate-files", "Read from separate files instead of consolidated files", false).option("--su, --suffix <suffix>", "Suffix to add to the component name").action(async (componentName, options) => {
   konsola.title(`${commands.COMPONENTS}`, colorPalette.COMPONENTS, componentName ? `Pushing component ${componentName}...` : "Pushing components...");
-  const verbose = program$b.opts().verbose;
+  const verbose = program$d.opts().verbose;
   const { space, path } = componentsCommand.opts();
   const { filter } = options;
   const fromSpace = options.from || space;
@@ -3775,11 +3846,11 @@ const saveLanguagesToFile = async (space, internationalizationOptions, options)
   }
 };
 
-const program$a = getProgram();
-const languagesCommand = program$a.command(commands.LANGUAGES).alias("lang").description(`Manage your space's languages`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/languages");
+const program$c = getProgram();
+const languagesCommand = program$c.command(commands.LANGUAGES).alias("lang").description(`Manage your space's languages`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/languages");
 languagesCommand.command("pull").description(`Download your space's languages schema as json`).option("-f, --filename <filename>", "filename to save the file as <filename>.<suffix>.json").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. languages.<suffix>.json). By default, the space ID is used.").action(async (options) => {
   konsola.title(`${commands.LANGUAGES}`, colorPalette.LANGUAGES);
-  const verbose = program$a.opts().verbose;
+  const verbose = program$c.opts().verbose;
   const { space, path } = languagesCommand.opts();
   const { filename = "languages", suffix = options.space } = options;
   const { state, initializeSession } = session();
@@ -3826,8 +3897,8 @@ languagesCommand.command("pull").description(`Download your space's languages sc
   konsola.br();
 });
 
-const program$9 = getProgram();
-const migrationsCommand = program$9.command(commands.MIGRATIONS).alias("mig").description(`Manage your space's migrations`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/migrations");
+const program$b = getProgram();
+const migrationsCommand = program$b.command(commands.MIGRATIONS).alias("mig").description(`Manage your space's migrations`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/migrations");
 
 const getMigrationTemplate = () => {
   return `export default function (block) {
@@ -3945,11 +4016,29 @@ const fetchStory = async (spaceId, storyId) => {
       },
       throwOnError: true
     });
-    return data?.story;
+    return data.story;
   } catch (error) {
     handleAPIError("pull_story", error);
   }
 };
+const createStory = async (spaceId, payload) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.stories.create({
+      path: {
+        space_id: spaceId
+      },
+      body: {
+        story: payload.story,
+        publish: payload.publish
+      },
+      throwOnError: true
+    });
+    return data?.story;
+  } catch (maybeError) {
+    handleAPIError("create_story", toError(maybeError));
+  }
+};
 const updateStory = async (spaceId, storyId, payload) => {
   try {
     const client = mapiClient();
@@ -3965,9 +4054,14 @@ const updateStory = async (spaceId, storyId, payload) => {
       },
       throwOnError: true
     });
-    return data?.story;
-  } catch (error) {
-    handleAPIError("update_story", error);
+    const { story } = data;
+    if (!story) {
+      throw new Error("Failed to update story");
+    }
+    return story;
+  } catch (maybeError) {
+    handleAPIError("update_story", toError(maybeError));
+    throw maybeError;
   }
 };
 
@@ -4424,6 +4518,49 @@ const isStoryPublishedWithoutChanges = (story) => {
 const isStoryWithUnpublishedChanges = (story) => {
   return story.published && story.unpublished_changes;
 };
+const toComponent = (maybeComponent) => {
+  if (maybeComponent.component_group_uuid === void 0) {
+    return null;
+  }
+  return maybeComponent;
+};
+const findComponentSchemas = async (directoryPath) => {
+  const files = await readdir(directoryPath).catch((error) => {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
+  const fileContents = files.filter((f) => path.extname(f) === ".json").map((f) => {
+    const filePath = path.join(directoryPath, f);
+    const fileContent = readFileSync(filePath, "utf-8");
+    return JSON.parse(fileContent);
+  });
+  const components = [];
+  for (const content of fileContents) {
+    if (Array.isArray(content)) {
+      for (const maybeComponent of content) {
+        const component2 = toComponent(maybeComponent);
+        if (component2) {
+          components.push(component2);
+        }
+      }
+      continue;
+    }
+    const component = toComponent(content);
+    if (component) {
+      components.push(component);
+    }
+  }
+  const schemas = {};
+  for (const component of components) {
+    schemas[component.name] = component.schema;
+  }
+  return schemas;
+};
+const getStoryFilename = (story) => {
+  return `${story.slug}_${story.uuid}.json`;
+};
 
 class UpdateStream extends Writable {
   constructor(options) {
@@ -4763,8 +4900,8 @@ migrationsCommand.command("rollback [migrationFile]").description("Rollback a mi
   }
 });
 
-const program$8 = getProgram();
-const typesCommand = program$8.command(commands.TYPES).alias("ts").description(`Generate types d.ts for your component schemas`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/types");
+const program$a = getProgram();
+const typesCommand = program$a.command(commands.TYPES).alias("ts").description(`Generate types d.ts for your component schemas`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/types");
 
 const getAssetJSONSchema = (title) => ({
   $id: "#/asset",
@@ -5674,13 +5811,13 @@ async function readConsolidatedFiles(resolvedPath, suffix) {
   };
 }
 
-const program$7 = getProgram();
+const program$9 = getProgram();
 typesCommand.command("generate").description("Generate types d.ts for your component schemas").option(
   "--filename <name>",
   "Base file name for all component types when generating a single declarations file (e.g. components.d.ts). Ignored when using --separate-files."
 ).option("--sf, --separate-files", "Generate one .d.ts file per component instead of a single combined file").option("--strict", "strict mode, no loose typing").option("--type-prefix <prefix>", "prefix to be prepended to all generated component type names").option("--type-suffix <suffix>", "suffix to be appended to all generated component type names").option("--suffix <suffix>", "Components suffix").option("--custom-fields-parser <path>", "Path to the parser file for Custom Field Types").option("--compiler-options <options>", "path to the compiler options from json-schema-to-typescript").action(async (options) => {
   konsola.title(`${commands.TYPES}`, colorPalette.TYPES, "Generating types...");
-  const verbose = program$7.opts().verbose;
+  const verbose = program$9.opts().verbose;
   const { space, path } = typesCommand.opts();
   const spinner = new Spinner({
     verbose: !isVitest
@@ -5733,8 +5870,8 @@ typesCommand.command("generate").description("Generate types d.ts for your compo
   }
 });
 
-const program$6 = getProgram();
-const datasourcesCommand = program$6.command(commands.DATASOURCES).alias("ds").description(`Manage your space's datasources`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/datasources");
+const program$8 = getProgram();
+const datasourcesCommand = program$8.command(commands.DATASOURCES).alias("ds").description(`Manage your space's datasources`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/datasources");
 
 async function fetchAllPages(fetchFunction, extractDataFunction, page = 1, collectedItems = []) {
   const { data, response } = await fetchFunction(page);
@@ -5840,10 +5977,10 @@ const saveDatasourcesToFiles = async (space, datasources, options) => {
   }
 };
 
-const program$5 = getProgram();
+const program$7 = getProgram();
 datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <filename>", "custom name to be used in file(s) name instead of space id").option("--sf, --separate-files", "Argument to create a single file for each datasource").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. datasources.<suffix>.json)").description("Pull datasources from your space").action(async (datasourceName, options) => {
   konsola.title(`${commands.DATASOURCES}`, colorPalette.DATASOURCES, datasourceName ? `Pulling datasource ${datasourceName}...` : "Pulling datasources...");
-  const verbose = program$5.opts().verbose;
+  const verbose = program$7.opts().verbose;
   const { space, path } = datasourcesCommand.opts();
   const {
     separateFiles = false,
@@ -5921,10 +6058,10 @@ datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <file
   }
 });
 
-const program$4 = getProgram();
+const program$6 = getProgram();
 datasourcesCommand.command("push [datasourceName]").description(`Push your space's datasources schema as json`).option("-f, --from <from>", "source space id").option("--fi, --filter <filter>", "glob filter to apply to the datasources before pushing").option("--sf, --separate-files", "Read from separate files instead of consolidated files").option("--su, --suffix <suffix>", "Suffix to add to the datasource name").action(async (datasourceName, options) => {
   konsola.title(`${commands.DATASOURCES}`, colorPalette.DATASOURCES, datasourceName ? `Pushing datasource ${datasourceName}...` : "Pushing datasources...");
-  const verbose = program$4.opts().verbose;
+  const verbose = program$6.opts().verbose;
   const { space, path } = datasourcesCommand.opts();
   const { filter } = options;
   const fromSpace = options.from || space;
@@ -6300,13 +6437,13 @@ async function promptForLogin(verbose) {
     return null;
   }
 }
-const program$3 = getProgram();
-program$3.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-t, --template <template>", "technology starter template").option("-b, --blueprint <blueprint>", "[DEPRECATED] use --template instead").option("--skip-space", "skip space creation").option("--token <token>", "Storyblok access token (skip space creation and use this token)").option(
+const program$5 = getProgram();
+program$5.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-t, --template <template>", "technology starter template").option("-b, --blueprint <blueprint>", "[DEPRECATED] use --template instead").option("--skip-space", "skip space creation").option("--token <token>", "Storyblok access token (skip space creation and use this token)").option(
   "-r, --region <region>",
   `The region to apply to the generated project template (does not affect space creation).`
 ).action(async (projectPath, options) => {
   konsola.title(`${commands.CREATE}`, colorPalette.CREATE);
-  const verbose = program$3.opts().verbose;
+  const verbose = program$5.opts().verbose;
   const { template, blueprint, token } = options;
   if (options.region && !isRegion(options.region)) {
     handleError(new CommandError(`The provided region: ${options.region} is not valid. Please use one of the following values: ${Object.values(regions).join(" | ")}`));
@@ -6532,13 +6669,13 @@ program$3.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   konsola.br();
 });
 
-const program$2 = getProgram();
-const logsCommand = program$2.command(commands.LOGS).alias("lg").description(`Inspect and manage logs.`).option("-s, --space <space>", "The space ID.").option("-p, --path <path>", "Path to the directory containing the logs directory. Defaults to '.storyblok'.");
+const program$4 = getProgram();
+const logsCommand = program$4.command(commands.LOGS).alias("lg").description(`Inspect and manage logs.`).option("-s, --space <space>", "The space ID.").option("-p, --path <path>", "Path to the directory containing the logs directory. Defaults to '.storyblok'.");
 
 logsCommand.command("list").description("List logs").action(async () => {
   const { space, path } = logsCommand.opts();
   const ui = getUI();
-  const logsPath = resolveCommandPath(directories.log, space, path);
+  const logsPath = resolveCommandPath(directories.logs, space, path);
   const logFiles = FileTransport.listLogFiles(logsPath);
   if (logFiles.length === 0) {
     ui.info(`No logs found for space "${space}".`);
@@ -6551,18 +6688,18 @@ logsCommand.command("list").description("List logs").action(async () => {
 logsCommand.command("prune").description("Prune logs").option("--keep <number>", "Max number of log files to keep (default `0`, meaning remove all)", Number.parseInt, 0).action(async ({ keep }) => {
   const { space, path } = logsCommand.opts();
   const ui = getUI();
-  const logsPath = resolveCommandPath(directories.log, space, path);
+  const logsPath = resolveCommandPath(directories.logs, space, path);
   const deletedFilesCount = FileTransport.pruneLogFiles(logsPath, keep);
   ui.info(`Deleted ${deletedFilesCount} log file${deletedFilesCount === 1 ? "" : "s"}`);
 });
 
-const program$1 = getProgram();
-const reportsCommand = program$1.command(commands.REPORTS).alias("rp").description("Inspect and manage reports.").option("-s, --space <space>", "The space ID.").option("-p, --path <path>", "Path to the directory containing the reports directory. Defaults to '.storyblok'.");
+const program$3 = getProgram();
+const reportsCommand = program$3.command(commands.REPORTS).alias("rp").description("Inspect and manage reports.").option("-s, --space <space>", "The space ID.").option("-p, --path <path>", "Path to the directory containing the reports directory. Defaults to '.storyblok'.");
 
 reportsCommand.command("list").description("List reports").action(async () => {
   const { space, path } = reportsCommand.opts();
   const ui = getUI();
-  const reportsPath = resolveCommandPath(directories.report, space, path);
+  const reportsPath = resolveCommandPath(directories.reports, space, path);
   const reportFiles = Reporter.listReportFiles(reportsPath, ".jsonl");
   if (reportFiles.length === 0) {
     ui.info(`No reports found for space "${space}".`);
@@ -6575,11 +6712,2248 @@ reportsCommand.command("list").description("List reports").action(async () => {
 reportsCommand.command("prune").description("Prune reports").option("--keep <number>", "Max number of report files to keep (default `0`, meaning remove all)", Number.parseInt, 0).action(async ({ keep }) => {
   const { space, path } = reportsCommand.opts();
   const ui = getUI();
-  const reportsPath = resolveCommandPath(directories.report, space, path);
+  const reportsPath = resolveCommandPath(directories.reports, space, path);
   const deletedFilesCount = Reporter.pruneReportFiles(reportsPath, keep, ".jsonl");
   ui.info(`Deleted ${deletedFilesCount} report file${deletedFilesCount === 1 ? "" : "s"}`);
 });
 
+const program$2 = getProgram();
+const assetsCommand = program$2.command(commands.ASSETS).description(`Manage your space's assets`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "base path to store assets (default .storyblok)");
+
+const fetchAssets = async ({ spaceId, params }) => {
+  try {
+    const client = mapiClient();
+    const { data, response } = await client.assets.list({
+      path: {
+        space_id: spaceId
+      },
+      query: {
+        ...params,
+        per_page: params?.per_page || 100,
+        page: params?.page || 1
+      },
+      throwOnError: true
+    });
+    const assets = (data?.assets || []).filter((asset) => Boolean(asset?.id && asset?.filename));
+    return {
+      assets,
+      headers: response.headers
+    };
+  } catch (maybeError) {
+    handleAPIError("pull_assets", toError(maybeError));
+    throw maybeError;
+  }
+};
+const downloadFile = async (filename) => {
+  const response = await fetch(filename);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${filename}`);
+  }
+  return response.arrayBuffer();
+};
+const getSignedAssetUrl = async (filename, assetToken, region) => {
+  try {
+    const client = new Storyblok({
+      accessToken: assetToken,
+      region: region || "eu"
+    });
+    const response = await client.get("cdn/assets/me", {
+      filename
+    });
+    return response.data.asset.signed_url;
+  } catch (maybeError) {
+    handleAPIError("pull_asset", toError(maybeError));
+    throw maybeError;
+  }
+};
+const fetchAssetFolders = async ({ spaceId }) => {
+  try {
+    const client = mapiClient();
+    const { data, response } = await client.assetFolders.list({
+      path: {
+        space_id: spaceId
+      },
+      throwOnError: true
+    });
+    return {
+      asset_folders: data.asset_folders || [],
+      headers: response.headers
+    };
+  } catch (maybeError) {
+    handleAPIError("pull_asset_folders", toError(maybeError));
+    throw maybeError;
+  }
+};
+const createAssetFolder = async (folder, {
+  spaceId
+}) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.assetFolders.create({
+      path: {
+        space_id: spaceId
+      },
+      body: { asset_folder: folder },
+      throwOnError: true
+    });
+    const { asset_folder } = data;
+    if (!asset_folder) {
+      throw new Error("Failed to create asset folder");
+    }
+    return asset_folder;
+  } catch (maybeError) {
+    handleAPIError("push_asset_folder", toError(maybeError));
+    throw maybeError;
+  }
+};
+const updateAssetFolder = async (folder, {
+  spaceId
+}) => {
+  try {
+    const client = mapiClient();
+    await client.assetFolders.update({
+      path: {
+        asset_folder_id: folder.id,
+        space_id: spaceId
+      },
+      body: { asset_folder: folder },
+      throwOnError: true
+    });
+    return folder;
+  } catch (maybeError) {
+    handleAPIError("push_asset_folder", toError(maybeError));
+    throw maybeError;
+  }
+};
+const requestAssetUpload = async (asset, { spaceId }) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.assets.upload({
+      path: {
+        space_id: spaceId
+      },
+      body: {
+        // @ts-expect-error Our types are wrong, id is optional but allowed.
+        id: asset.id,
+        filename: asset.short_filename,
+        asset_folder_id: asset.asset_folder_id ?? void 0,
+        is_private: asset.is_private
+      },
+      throwOnError: true
+    });
+    const signedUpload = data;
+    if (!signedUpload?.id || !signedUpload?.post_url || !signedUpload?.fields) {
+      throw new Error("Failed to request signed upload!");
+    }
+    return signedUpload;
+  } catch (maybeError) {
+    handleAPIError("push_asset_sign", toError(maybeError));
+    throw maybeError;
+  }
+};
+const uploadAssetToS3 = async (asset, fileBuffer, {
+  signedUpload
+}) => {
+  if (!signedUpload?.id || !signedUpload?.post_url || !signedUpload?.fields) {
+    throw new Error("Invalid signed upload!");
+  }
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(signedUpload.fields)) {
+    formData.append(key, value);
+  }
+  const contentType = signedUpload.fields["Content-Type"] || "application/octet-stream";
+  formData.append("file", new File([Buffer.from(fileBuffer)], asset.short_filename, { type: contentType }));
+  const response = await fetch(signedUpload.post_url, {
+    method: "POST",
+    body: formData
+  });
+  if (!response.ok) {
+    handleAPIError("push_asset_upload", new Error("Failed to upload asset to storage"));
+    return;
+  }
+  return response;
+};
+const finishAssetUpload = async (assetId, {
+  spaceId
+}) => {
+  try {
+    const client = mapiClient();
+    await client.assets.finalize({
+      path: {
+        space_id: spaceId,
+        signed_response_object_id: String(assetId)
+      },
+      throwOnError: true
+    });
+    const { data } = await client.assets.get({
+      path: {
+        space_id: spaceId,
+        asset_id: assetId
+      },
+      throwOnError: true
+    });
+    return data;
+  } catch (maybeError) {
+    handleAPIError("push_asset_finish", toError(maybeError));
+    throw maybeError;
+  }
+};
+const uploadAsset = async (asset, fileBuffer, { spaceId }) => {
+  const signed = await requestAssetUpload(asset, {
+    spaceId
+  });
+  const uploadResponse = await uploadAssetToS3(asset, fileBuffer, {
+    signedUpload: signed
+  });
+  if (!uploadResponse?.ok) {
+    throw new Error("Error uploading asset to S3!");
+  }
+  return finishAssetUpload(Number(signed.id), {
+    spaceId
+  });
+};
+const sha256 = (data) => {
+  const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return createHash("sha256").update(buffer).digest("hex");
+};
+const downloadAssetFile = async (asset, options) => {
+  let url = asset.filename;
+  if (asset.is_private) {
+    if (!options.assetToken) {
+      throw new Error(`Asset ${asset.filename} is private but no asset token was provided. Use --asset-token to provide a token.`);
+    }
+    url = await getSignedAssetUrl(asset.filename, options.assetToken, options.region);
+  }
+  return downloadFile(url);
+};
+const updateAsset = async (asset, fileBuffer, {
+  spaceId
+}) => {
+  try {
+    const assetWithNewFilename = { ...asset };
+    if (fileBuffer) {
+      const uploadedAsset = await uploadAsset({
+        id: asset.id,
+        asset_folder_id: asset.asset_folder_id,
+        short_filename: asset.short_filename || basename(asset.filename)
+      }, fileBuffer, { spaceId });
+      assetWithNewFilename.filename = uploadedAsset.filename;
+      assetWithNewFilename.short_filename = uploadedAsset.short_filename;
+    }
+    const client = mapiClient();
+    await client.assets.update({
+      path: {
+        space_id: spaceId,
+        asset_id: assetWithNewFilename.id
+      },
+      body: {
+        asset: assetWithNewFilename
+      },
+      throwOnError: true
+    });
+    return assetWithNewFilename;
+  } catch (maybeError) {
+    handleAPIError("push_asset_update", toError(maybeError));
+    throw maybeError;
+  }
+};
+const createAsset = async (asset, fileBuffer, { spaceId }) => {
+  const createdAsset = await uploadAsset({
+    asset_folder_id: asset.asset_folder_id,
+    short_filename: asset.short_filename,
+    alt: asset.alt,
+    title: asset.title,
+    copyright: asset.copyright,
+    source: asset.source,
+    is_private: asset.is_private
+  }, fileBuffer, { spaceId });
+  const hasUpdatableMetadata = Boolean(
+    asset.alt || asset.title || asset.copyright || asset.source || asset.is_private || asset.meta_data && Object.keys(asset.meta_data).length > 0
+  );
+  if (hasUpdatableMetadata) {
+    const updatedAsset = await updateAsset({
+      ...asset,
+      id: createdAsset.id,
+      filename: createdAsset.filename
+    }, null, {
+      spaceId
+    });
+    if (!updatedAsset) {
+      throw new Error("Updating the created asset failed!");
+    }
+    return updatedAsset;
+  }
+  return createdAsset;
+};
+
+const parseAssetData = (raw) => {
+  if (!raw) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Asset data must be a JSON object.");
+    }
+    return parsed;
+  } catch (maybeError) {
+    throw new Error(`Invalid --data JSON: ${toError(maybeError).message}`);
+  }
+};
+const getSidecarFilename = (assetBinaryPath) => {
+  return join(dirname$1(assetBinaryPath), `${basename(assetBinaryPath, extname(assetBinaryPath))}.json`);
+};
+const loadSidecarAssetData = async (assetBinaryPath) => {
+  const sidecarPath = getSidecarFilename(assetBinaryPath);
+  try {
+    const sidecarRaw = await readFile$1(sidecarPath, "utf8");
+    try {
+      return parseAssetData(sidecarRaw);
+    } catch (maybeError) {
+      throw new Error(`Invalid sidecar JSON: ${toError(maybeError).message}`);
+    }
+  } catch (maybeError) {
+    const error = toError(maybeError);
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw new Error(`Failed to read sidecar asset data: ${error.message}`);
+  }
+};
+const isRemoteSource = (assetBinaryPath) => {
+  try {
+    const url = new URL(assetBinaryPath);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+const isValidManifestEntry = (entry) => Boolean(typeof entry.old_id === "number" && typeof entry.new_id === "number" && entry.old_filename && entry.new_filename);
+const loadAssetMap = async (manifestFile) => {
+  const manifest = await loadManifest(manifestFile);
+  return new Map([
+    ...manifest.filter(isValidManifestEntry).map((e) => [
+      Number(e.old_id),
+      {
+        old: { id: Number(e.old_id), filename: e.old_filename || "" },
+        new: { id: Number(e.new_id), filename: e.new_filename || "" }
+      }
+    ])
+  ]);
+};
+const loadAssetFolderMap = async (manifestFile) => {
+  const manifest = await loadManifest(manifestFile);
+  return new Map(manifest.map((e) => [Number(e.old_id), Number(e.new_id)]));
+};
+const getAssetNameAndExt = (asset) => {
+  const filename = asset.short_filename || (asset.filename ? basename(asset.filename) : void 0);
+  if (!filename) {
+    throw new Error(`Filename for asset with id ${asset.id} could not be determined!`);
+  }
+  const ext = extname(filename);
+  const name = sanitizeFilename(filename.replace(ext, ""));
+  return { name, ext };
+};
+const getAssetFilename = (asset) => {
+  const { name } = getAssetNameAndExt(asset);
+  return `${name}_${asset.id}.json`;
+};
+const getAssetBinaryFilename = (asset) => {
+  const { name, ext } = getAssetNameAndExt(asset);
+  return `${name}_${asset.id}${ext}`;
+};
+const getFolderFilename = (folder) => {
+  const sanitizedName = sanitizeFilename(folder.name || "");
+  const baseName = sanitizedName || folder.uuid;
+  return `${baseName}_${folder.uuid}.json`;
+};
+
+const apiConcurrencyLock$1 = new Sema(12);
+const fetchAssetsStream = ({
+  spaceId,
+  params = {},
+  setTotalAssets,
+  setTotalPages,
+  onIncrement,
+  onPageSuccess,
+  onPageError
+}) => {
+  const listGenerator = async function* assetListIterator() {
+    let perPage = 100;
+    let page = 1;
+    let totalPages = 1;
+    setTotalPages?.(totalPages);
+    while (page <= totalPages) {
+      try {
+        const result = await fetchAssets({
+          spaceId,
+          params: {
+            ...params,
+            per_page: perPage,
+            page
+          }
+        });
+        const { headers, assets } = result;
+        const total = Number(headers.get("Total"));
+        perPage = Number(headers.get("Per-Page")) || perPage;
+        totalPages = Math.max(1, Math.ceil(total / perPage));
+        setTotalAssets?.(total);
+        setTotalPages?.(totalPages);
+        onPageSuccess?.(page, totalPages);
+        for (const asset of assets) {
+          yield asset;
+        }
+        page += 1;
+      } catch (maybeError) {
+        onPageError?.(toError(maybeError), page, totalPages);
+        break;
+      } finally {
+        onIncrement?.();
+      }
+    }
+  };
+  return Readable.from(listGenerator());
+};
+const downloadAssetStream = ({
+  assetToken,
+  region,
+  onIncrement,
+  onAssetSuccess,
+  onAssetError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Transform({
+    objectMode: true,
+    async transform(asset, _encoding, callback) {
+      await apiConcurrencyLock$1.acquire();
+      const task = downloadAssetFile(asset, { assetToken, region }).then((fileBuffer) => {
+        if (!fileBuffer) {
+          throw new Error("Invalid asset file!");
+        }
+        onAssetSuccess?.(asset);
+        this.push({ asset, fileBuffer });
+      }).catch((maybeError) => {
+        onAssetError?.(toError(maybeError), asset);
+      }).finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock$1.release();
+        processing.delete(task);
+      });
+      processing.add(task);
+      callback();
+    },
+    flush(callback) {
+      Promise.allSettled(processing).finally(() => callback());
+    }
+  });
+};
+const makeWriteAssetFSTransport = ({ directoryPath }) => async (asset, fileBuffer) => {
+  const assetBinaryPath = join(directoryPath, getAssetBinaryFilename(asset));
+  const assetPath = join(directoryPath, getAssetFilename(asset));
+  await saveToFile(assetBinaryPath, Buffer.from(fileBuffer));
+  await saveToFile(assetPath, JSON.stringify(asset, null, 2));
+  return asset;
+};
+const writeAssetStream = ({
+  writeAsset,
+  onIncrement,
+  onAssetSuccess,
+  onAssetError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Writable({
+    objectMode: true,
+    async write(payload, _encoding, callback) {
+      await apiConcurrencyLock$1.acquire();
+      const task = (async () => {
+        try {
+          await writeAsset(payload.asset, payload.fileBuffer);
+          onAssetSuccess?.(payload.asset);
+        } catch (maybeError) {
+          onAssetError?.(toError(maybeError), payload.asset);
+        }
+      })();
+      processing.add(task);
+      task.finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock$1.release();
+        processing.delete(task);
+      });
+      callback();
+    },
+    final(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+const fetchAssetFoldersStream = ({
+  spaceId,
+  setTotalFolders,
+  onSuccess,
+  onError
+}) => {
+  const listGenerator = async function* folderListIterator() {
+    try {
+      const result = await fetchAssetFolders({ spaceId });
+      const { asset_folders } = result;
+      const total = asset_folders.length;
+      setTotalFolders?.(total);
+      onSuccess?.(asset_folders);
+      for (const folder of asset_folders) {
+        yield folder;
+      }
+    } catch (maybeError) {
+      onError?.(toError(maybeError));
+    }
+  };
+  return Readable.from(listGenerator());
+};
+const makeWriteAssetFolderFSTransport = ({ directoryPath }) => async (folder) => {
+  const filename = getFolderFilename(folder);
+  await saveToFile(join(directoryPath, "folders", filename), JSON.stringify(folder, null, 2));
+  return folder;
+};
+const writeAssetFolderStream = ({
+  writeAssetFolder,
+  onIncrement,
+  onFolderSuccess,
+  onFolderError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Writable({
+    objectMode: true,
+    async write(folder, _encoding, callback) {
+      await apiConcurrencyLock$1.acquire();
+      const task = (async () => {
+        try {
+          await writeAssetFolder(folder);
+          onFolderSuccess?.(folder);
+        } catch (maybeError) {
+          onFolderError?.(toError(maybeError), folder);
+        }
+      })();
+      processing.add(task);
+      task.finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock$1.release();
+        processing.delete(task);
+      });
+      callback();
+    },
+    final(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+const readLocalAssetFoldersStream = ({
+  directoryPath,
+  setTotalFolders,
+  onFolderError
+}) => {
+  const iterator = async function* readFolders() {
+    try {
+      const files = await readdir(directoryPath);
+      const jsonFiles = new Set(files.filter((file) => file.endsWith(".json")));
+      setTotalFolders?.(jsonFiles.size);
+      const processed = /* @__PURE__ */ new Set();
+      let maxIterations = jsonFiles.size * jsonFiles.size;
+      while (jsonFiles.size > 0 && maxIterations-- > 0) {
+        for (const file of jsonFiles) {
+          try {
+            const filePath = join(directoryPath, file);
+            const content = await readFile$1(filePath, "utf8");
+            const folder = JSON.parse(content);
+            jsonFiles.delete(file);
+            if (!folder.parent_id || processed.has(folder.parent_id)) {
+              processed.add(folder.id);
+              yield {
+                folder,
+                context: {
+                  localFilePath: filePath
+                }
+              };
+            } else {
+              jsonFiles.add(file);
+            }
+          } catch (maybeError) {
+            onFolderError?.(toError(maybeError));
+          }
+        }
+      }
+      if (jsonFiles.size > 0) {
+        onFolderError?.(new Error(`Unable to resolve folder dependencies for: ${[...jsonFiles].join(", ")}`));
+      }
+    } catch (maybeError) {
+      const error = toError(maybeError);
+      if ("code" in error && error.code === "ENOENT") {
+        return;
+      }
+      onFolderError?.(error);
+    }
+  };
+  return Readable.from(iterator());
+};
+const makeCreateAssetFolderAPITransport = ({ spaceId }) => (folder) => createAssetFolder({
+  name: folder.name,
+  parent_id: folder.parent_id ?? void 0
+}, {
+  spaceId
+});
+const makeUpdateAssetFolderAPITransport = ({ spaceId }) => (folder) => updateAssetFolder(folder, { spaceId });
+const makeGetAssetFolderAPITransport = ({ spaceId }) => async (folderId) => {
+  const { data, response } = await mapiClient().assetFolders.get({
+    path: {
+      asset_folder_id: folderId,
+      space_id: spaceId
+    }
+  });
+  if (!response.ok && response.status !== 404) {
+    handleAPIError("pull_asset_folder", new FetchError(response.statusText, response));
+  }
+  return data?.asset_folder;
+};
+const makeCleanupAssetFolderFSTransport = () => async ({ localFilePath }) => await unlink(localFilePath);
+const upsertAssetFolderStream = ({
+  transports,
+  maps,
+  onIncrement,
+  onFolderSuccess,
+  onFolderError
+}) => {
+  return new Writable({
+    objectMode: true,
+    async write({ folder, context }, _encoding, callback) {
+      try {
+        const remoteParentId = folder.parent_id && (maps.assetFolders.get(folder.parent_id) || folder.parent_id);
+        const remoteFolderId = maps.assetFolders.get(folder.id) || folder.id;
+        const upsertFolder = {
+          ...folder,
+          id: remoteFolderId,
+          parent_id: remoteParentId
+        };
+        const existingRemoteFolder = await transports.getAssetFolder(remoteFolderId);
+        const newRemoteFolder = existingRemoteFolder ? await transports.updateAssetFolder({ ...upsertFolder, parent_id: remoteParentId !== null ? remoteParentId : void 0 }) : await transports.createAssetFolder(upsertFolder);
+        if (!maps.assetFolders.get(folder.id)) {
+          await transports.appendAssetFolderManifest(folder, newRemoteFolder);
+        }
+        await transports.cleanupAssetFolder?.({ localFilePath: context.localFilePath });
+        onFolderSuccess?.(folder, newRemoteFolder);
+      } catch (maybeError) {
+        onFolderError?.(toError(maybeError), folder);
+      } finally {
+        onIncrement?.();
+        callback();
+      }
+    }
+  });
+};
+const readLocalAssetsStream = ({
+  directoryPath,
+  setTotalAssets,
+  onAssetError
+}) => {
+  const iterator = async function* readAssets() {
+    try {
+      const files = await readdir(directoryPath);
+      const metadataFiles = files.filter((file) => file.endsWith(".json") && file !== "manifest.jsonl");
+      setTotalAssets?.(metadataFiles.length);
+      for (const file of metadataFiles) {
+        const filePath = join(directoryPath, file);
+        try {
+          const statResult = await stat(filePath);
+          if (!statResult.isFile()) {
+            continue;
+          }
+          const metadataContent = await readFile$1(filePath, "utf8");
+          const assetRaw = JSON.parse(metadataContent);
+          const asset = {
+            ...assetRaw,
+            short_filename: assetRaw.short_filename || basename(assetRaw.filename)
+          };
+          const baseName = parse(file).name;
+          const extFromMetadata = extname(asset.short_filename || asset.filename) || "";
+          const assetBinaryPath = join(directoryPath, `${baseName}${extFromMetadata}`);
+          const fileBuffer = await readFile$1(assetBinaryPath);
+          yield {
+            asset,
+            context: {
+              fileBuffer,
+              assetBinaryPath,
+              assetPath: filePath
+            }
+          };
+        } catch (maybeError) {
+          onAssetError?.(toError(maybeError));
+        }
+      }
+    } catch (maybeError) {
+      onAssetError?.(toError(maybeError));
+    }
+  };
+  return Readable.from(iterator());
+};
+const readSingleAssetStream = ({
+  asset,
+  assetBinaryPath,
+  onAssetError
+}) => {
+  const iterator = async function* readSingleAsset() {
+    try {
+      if (!isRemoteSource(assetBinaryPath) && !await fileExists(assetBinaryPath)) {
+        throw new Error("Asset path must point to a file.");
+      }
+      const fileBuffer = isRemoteSource(assetBinaryPath) ? await downloadFile(assetBinaryPath) : await readFile$1(assetBinaryPath);
+      yield {
+        asset,
+        context: {
+          fileBuffer,
+          assetBinaryPath
+        }
+      };
+    } catch (maybeError) {
+      onAssetError?.(toError(maybeError));
+    }
+  };
+  return Readable.from(iterator());
+};
+const makeCreateAssetAPITransport = ({ spaceId }) => (asset, fileBuffer) => createAsset(asset, fileBuffer, { spaceId });
+const makeUpdateAssetAPITransport = ({
+  spaceId
+}) => (asset, fileBuffer) => updateAsset(asset, fileBuffer, {
+  spaceId
+});
+const makeAppendAssetManifestFSTransport = ({ manifestFile }) => async (localAsset, remoteAsset) => {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  await appendToFile(manifestFile, JSON.stringify({
+    old_id: localAsset.id,
+    new_id: remoteAsset.id,
+    old_filename: localAsset.filename,
+    new_filename: remoteAsset.filename,
+    created_at: createdAt
+  }));
+};
+const makeAppendAssetFolderManifestFSTransport = ({ manifestFile }) => async (localFolder, remoteFolder) => {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  await appendToFile(manifestFile, JSON.stringify({
+    old_id: localFolder.id,
+    new_id: remoteFolder.id,
+    created_at: createdAt
+  }));
+};
+const makeGetAssetAPITransport = ({ spaceId }) => async (assetId) => {
+  const { data, response } = await mapiClient().assets.get({
+    path: {
+      space_id: spaceId,
+      asset_id: assetId
+    }
+  });
+  if (!response.ok && response.status !== 404) {
+    handleAPIError("pull_asset", new FetchError(response.statusText, response));
+  }
+  if (data?.deleted_at) {
+    return void 0;
+  }
+  return data;
+};
+const saveDelete = async (filePath) => {
+  if (await fileExists(filePath)) {
+    await unlink(filePath);
+  }
+};
+const makeCleanupAssetFSTransport = () => async ({ assetBinaryPath, assetPath }) => {
+  const assetOrSidecarPath = assetPath || getSidecarFilename(assetBinaryPath);
+  await Promise.all([
+    assetBinaryPath && saveDelete(assetBinaryPath),
+    assetOrSidecarPath && saveDelete(assetOrSidecarPath)
+  ]);
+};
+const hasId = (a) => {
+  return !!a && typeof a === "object" && "id" in a && typeof a.id === "number";
+};
+const hasShortFilename = (a) => {
+  return !!a && typeof a === "object" && "short_filename" in a && typeof a.short_filename === "string";
+};
+const isDataUnchanged = (localAsset, remoteAsset) => {
+  if (localAsset.asset_folder_id !== remoteAsset.asset_folder_id) {
+    return false;
+  }
+  if (localAsset.alt !== remoteAsset.alt || localAsset.title !== remoteAsset.title || localAsset.copyright !== remoteAsset.copyright || localAsset.source !== remoteAsset.source || localAsset.is_private !== remoteAsset.is_private) {
+    return false;
+  }
+  const localAssetMetadataEntries = Object.entries(localAsset.meta_data || {});
+  const remoteAssetMetadataEntries = Object.entries(remoteAsset.meta_data || {});
+  if (localAssetMetadataEntries.length !== remoteAssetMetadataEntries.length) {
+    return false;
+  }
+  const hasChanges = localAssetMetadataEntries.some(([k, v]) => remoteAsset.meta_data && remoteAsset.meta_data[k] !== v);
+  return !hasChanges;
+};
+const isAssetUnchanged = async (localAsset, remoteAsset, localFileBuffer, downloadAssetFileTransport) => {
+  const remoteFileBuffer = await downloadAssetFileTransport(remoteAsset);
+  const isFileUnchanged = sha256(localFileBuffer) === sha256(remoteFileBuffer);
+  if (!isFileUnchanged) {
+    return false;
+  }
+  return isDataUnchanged(localAsset, remoteAsset);
+};
+const makeDownloadAssetFileTransport = ({
+  assetToken,
+  region
+}) => (asset) => downloadAssetFile(asset, { assetToken, region });
+const processAsset = async ({
+  localAsset,
+  fileBuffer,
+  assetBinaryPath,
+  assetPath,
+  transports,
+  maps
+}) => {
+  const remoteFolderId = localAsset.asset_folder_id && (maps.assetFolders.get(localAsset.asset_folder_id) || localAsset.asset_folder_id);
+  const remoteAssetId = hasId(localAsset) ? maps.assets.get(localAsset.id)?.new.id || localAsset.id : void 0;
+  const remoteAsset = remoteAssetId ? await transports.getAsset(remoteAssetId) : null;
+  let newRemoteAsset;
+  let status;
+  if (remoteAsset) {
+    const updatePayload = {
+      ...remoteAsset,
+      ...localAsset,
+      id: remoteAsset.id,
+      asset_folder_id: remoteFolderId
+    };
+    const canSkip = await isAssetUnchanged(
+      updatePayload,
+      remoteAsset,
+      fileBuffer,
+      transports.downloadAssetFile
+    );
+    if (canSkip) {
+      newRemoteAsset = remoteAsset;
+      status = "skipped";
+    } else {
+      newRemoteAsset = await transports.updateAsset(updatePayload, fileBuffer);
+      status = "updated";
+    }
+  } else if (hasShortFilename(localAsset)) {
+    const createPayload = {
+      ...localAsset,
+      asset_folder_id: remoteFolderId
+    };
+    newRemoteAsset = await transports.createAsset(createPayload, fileBuffer);
+    status = "created";
+  } else {
+    throw new Error("Could neither create nor update the asset: Missing ID and Filename");
+  }
+  if (hasId(localAsset)) {
+    await transports.appendAssetManifest(localAsset, newRemoteAsset);
+  }
+  await transports.cleanupAsset?.({ assetBinaryPath, assetPath });
+  return { status, remoteAsset: newRemoteAsset };
+};
+const upsertAssetStream = ({
+  transports,
+  maps,
+  onIncrement,
+  onAssetSuccess,
+  onAssetSkipped,
+  onAssetError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Writable({
+    objectMode: true,
+    async write({ asset: localAsset, context }, _encoding, callback) {
+      await apiConcurrencyLock$1.acquire();
+      const task = (async () => {
+        try {
+          const { status, remoteAsset } = await processAsset({
+            localAsset,
+            fileBuffer: context.fileBuffer,
+            assetBinaryPath: context.assetBinaryPath,
+            assetPath: context.assetPath,
+            transports,
+            maps
+          });
+          if (status === "skipped") {
+            onAssetSkipped?.(localAsset, remoteAsset);
+          } else {
+            onAssetSuccess?.(localAsset, remoteAsset);
+          }
+        } catch (maybeError) {
+          onAssetError?.(toError(maybeError), localAsset);
+        }
+      })();
+      processing.add(task);
+      task.finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock$1.release();
+        processing.delete(task);
+      });
+      callback();
+    },
+    final(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+
+assetsCommand.command("pull").option("-d, --dry-run", "Preview changes without applying them to Storyblok").option("-q, --query <query>", 'Filter assets using Storyblok filter query syntax. Example: --query="search=my-file.jpg&with_tags=tag1,tag2"').option("--asset-token <token>", "Asset token for accessing private assets").description(`Download your space's assets as local files.`).action(async (options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  ui.title(`${commands.ASSETS}`, colorPalette.ASSETS, "Pulling assets...");
+  logger.info("Pulling assets started");
+  if (options.dryRun) {
+    ui.warn(`DRY RUN MODE ENABLED: No changes will be made.
+`);
+    logger.warn("Dry run mode enabled");
+  }
+  const { space, path: basePath, verbose } = command.optsWithGlobals();
+  const assetToken = options.assetToken;
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    process.exitCode = 2;
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
+    process.exitCode = 2;
+    return;
+  }
+  const { password, region } = state;
+  mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
+  const summary = {
+    folderResults: { total: 0, succeeded: 0, failed: 0 },
+    fetchAssetPages: { total: 0, succeeded: 0, failed: 0 },
+    fetchAssets: { total: 0, succeeded: 0, failed: 0 },
+    save: { total: 0, succeeded: 0, failed: 0 }
+  };
+  let fatalError = false;
+  try {
+    const folderProgress = ui.createProgressBar({ title: "Folders...".padEnd(25) });
+    const fetchAssetPagesProgress = ui.createProgressBar({ title: "Fetching Asset Pages...".padEnd(24) });
+    const fetchAssetsProgress = ui.createProgressBar({ title: "Fetching Assets...".padEnd(24) });
+    const saveProgress = ui.createProgressBar({ title: "Saving Assets...".padEnd(24) });
+    await pipeline$1(
+      fetchAssetFoldersStream({
+        spaceId: space,
+        setTotalFolders: (total) => {
+          summary.folderResults.total = total;
+          folderProgress.setTotal(total);
+        },
+        onSuccess: () => {
+          logger.info("Fetched asset folders");
+        },
+        onError: (error) => {
+          summary.folderResults.failed += 1;
+          summary.folderResults.total = summary.folderResults.total || 1;
+          folderProgress.setTotal(summary.folderResults.total);
+          logOnlyError(error);
+        }
+      }),
+      writeAssetFolderStream({
+        writeAssetFolder: options.dryRun ? async (folder) => folder : makeWriteAssetFolderFSTransport({
+          directoryPath: resolveCommandPath(directories.assets, space, basePath)
+        }),
+        onIncrement: () => {
+          folderProgress.increment();
+        },
+        onFolderSuccess: (folder) => {
+          logger.info("Saved folder", { folderId: folder.id });
+          summary.folderResults.succeeded += 1;
+        },
+        onFolderError: (error, folder) => {
+          summary.folderResults.failed += 1;
+          summary.folderResults.total = Math.max(summary.folderResults.total, summary.folderResults.succeeded + summary.folderResults.failed);
+          logOnlyError(error, { folderId: folder.id });
+        }
+      })
+    );
+    await pipeline$1(
+      fetchAssetsStream({
+        spaceId: space,
+        params: options.query ? Object.fromEntries(new URLSearchParams(options.query)) : {},
+        setTotalAssets: (total) => {
+          summary.fetchAssets.total = total;
+          summary.save.total = total;
+          fetchAssetsProgress.setTotal(total);
+          saveProgress.setTotal(total);
+        },
+        setTotalPages: (totalPages) => {
+          summary.fetchAssetPages.total = totalPages;
+          fetchAssetPagesProgress.setTotal(totalPages);
+        },
+        onIncrement: () => {
+          fetchAssetPagesProgress.increment();
+        },
+        onPageSuccess: (page, totalPages) => {
+          logger.info(`Fetched assets page ${page} of ${totalPages}`);
+          summary.fetchAssetPages.succeeded += 1;
+        },
+        onPageError: (error, page, totalPages) => {
+          summary.fetchAssetPages.failed += 1;
+          logOnlyError(error, { page, totalPages });
+        }
+      }),
+      downloadAssetStream({
+        assetToken,
+        region,
+        onIncrement: () => {
+          fetchAssetsProgress.increment();
+        },
+        onAssetSuccess: (asset) => {
+          logger.info("Fetched asset", { assetId: asset.id });
+          summary.fetchAssets.succeeded += 1;
+        },
+        onAssetError: (error, asset) => {
+          summary.fetchAssets.failed += 1;
+          summary.save.total -= 1;
+          saveProgress.setTotal(summary.save.total);
+          logOnlyError(error, { assetId: asset.id });
+        }
+      }),
+      writeAssetStream({
+        writeAsset: options.dryRun ? async (asset) => asset : makeWriteAssetFSTransport({
+          directoryPath: resolveCommandPath(directories.assets, space, basePath)
+        }),
+        onIncrement: () => {
+          saveProgress.increment();
+        },
+        onAssetSuccess: (asset) => {
+          logger.info("Saved asset", { assetId: asset.id });
+          summary.save.succeeded += 1;
+        },
+        onAssetError: (error, asset) => {
+          summary.save.failed += 1;
+          logOnlyError(error, { assetId: asset.id });
+        }
+      })
+    );
+  } catch (maybeError) {
+    fatalError = true;
+    handleError(toError(maybeError));
+  } finally {
+    logger.info("Pulling assets finished", summary);
+    ui.stopAllProgressBars();
+    const failedAssets = Math.max(summary.fetchAssets.failed, summary.save.failed);
+    const folderSummary = {
+      total: summary.folderResults.total,
+      succeeded: summary.folderResults.succeeded,
+      failed: summary.folderResults.failed
+    };
+    ui.info(`Pull results: ${summary.save.total} assets pulled, ${failedAssets} assets failed`);
+    ui.list([
+      `Folders: ${folderSummary.succeeded}/${folderSummary.total} succeeded, ${folderSummary.failed} failed.`,
+      `Fetching pages: ${summary.fetchAssetPages.succeeded}/${summary.fetchAssetPages.total} succeeded, ${summary.fetchAssetPages.failed} failed.`,
+      `Fetching assets: ${summary.fetchAssets.succeeded}/${summary.fetchAssets.total} succeeded, ${summary.fetchAssets.failed} failed.`,
+      `Saving assets: ${summary.save.succeeded}/${summary.save.total} succeeded, ${summary.save.failed} failed.`
+    ]);
+    const reporter = getReporter();
+    reporter.addSummary("folderResults", folderSummary);
+    reporter.addSummary("fetchAssetPagesResults", summary.fetchAssetPages);
+    reporter.addSummary("fetchAssetsResults", summary.fetchAssets);
+    reporter.addSummary("saveResults", summary.save);
+    reporter.finalize();
+    const failedTotal = summary.folderResults.failed + summary.fetchAssetPages.failed + summary.fetchAssets.failed + summary.save.failed;
+    process.exitCode = fatalError ? 2 : failedTotal > 0 ? 1 : 0;
+  }
+});
+
+const traverseAndMapBySchema = (data, {
+  schemas,
+  maps,
+  fieldRefMappers: fieldRefMappers2,
+  processedFields,
+  missingSchemas
+}) => {
+  const schema = schemas[data.component];
+  if (!schema) {
+    missingSchemas.add(data.component);
+    return data;
+  }
+  const dataNew = { ...data };
+  for (const [fieldName, fieldValue] of Object.entries(data)) {
+    const fieldSchema = schema[fieldName.replace(/__i18n__.*/, "")];
+    const fieldType = fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema && fieldSchema.type;
+    const fieldRefMapper = typeof fieldType === "string" && fieldRefMappers2[fieldType];
+    if (fieldSchema) {
+      processedFields.add(fieldSchema);
+    }
+    if (fieldRefMapper) {
+      dataNew[fieldName] = fieldRefMapper(fieldValue, {
+        schema: fieldSchema,
+        schemas,
+        maps,
+        fieldRefMappers: fieldRefMappers2,
+        processedFields,
+        missingSchemas
+      });
+    }
+  }
+  return dataNew;
+};
+const traverseAndMapRichtextDoc = (data, {
+  schemas,
+  maps,
+  fieldRefMappers: fieldRefMappers2,
+  processedFields,
+  missingSchemas
+}) => {
+  if (Array.isArray(data)) {
+    return data.map((item) => traverseAndMapRichtextDoc(item, {
+      schemas,
+      maps,
+      fieldRefMappers: fieldRefMappers2,
+      processedFields,
+      missingSchemas
+    }));
+  }
+  if (data && typeof data === "object") {
+    if (data.type === "link" && data.attrs.linktype === "story") {
+      return {
+        ...data,
+        attrs: {
+          ...data.attrs,
+          uuid: maps.stories?.get(data.attrs.uuid) || data.attrs.uuid
+        }
+      };
+    }
+    if (data.type === "blok") {
+      return {
+        ...data,
+        attrs: {
+          ...data.attrs,
+          body: data.attrs.body.map((d) => traverseAndMapBySchema(d, {
+            schemas,
+            maps,
+            fieldRefMappers: fieldRefMappers2,
+            processedFields,
+            missingSchemas
+          }))
+        }
+      };
+    }
+    const newData = {};
+    for (const [k, value] of Object.entries(data)) {
+      newData[k] = traverseAndMapRichtextDoc(value, {
+        schemas,
+        maps,
+        fieldRefMappers: fieldRefMappers2,
+        processedFields,
+        missingSchemas
+      });
+    }
+    return newData;
+  }
+  return data;
+};
+const richtextFieldRefMapper = (data, { schemas, maps, fieldRefMappers: fieldRefMappers2, processedFields, missingSchemas }) => traverseAndMapRichtextDoc(data, {
+  schemas,
+  maps,
+  fieldRefMappers: fieldRefMappers2,
+  processedFields,
+  missingSchemas
+});
+const multilinkFieldRefMapper = (data, { maps }) => {
+  if (data.linktype !== "story") {
+    return data;
+  }
+  return {
+    ...data,
+    id: maps.stories?.get(data.id) || data.id
+  };
+};
+const bloksFieldRefMapper = (data, { schemas, maps, fieldRefMappers: fieldRefMappers2, processedFields, missingSchemas }) => {
+  if (!Array.isArray(data)) {
+    throw new TypeError("Invalid data!");
+  }
+  return data.map((d) => traverseAndMapBySchema(d, {
+    schemas,
+    maps,
+    fieldRefMappers: fieldRefMappers2,
+    processedFields,
+    missingSchemas
+  }));
+};
+const assetFieldRefMapper = (data, { maps }) => {
+  const mappedAsset = typeof data.id === "number" ? maps.assets?.get(data.id) : void 0;
+  return {
+    ...data,
+    ...mappedAsset?.new
+  };
+};
+const multiassetFieldRefMapper = (data, options) => {
+  if (!Array.isArray(data)) {
+    throw new TypeError("Invalid data!");
+  }
+  return data.map((d) => assetFieldRefMapper(d, options));
+};
+const optionsFieldRefMapper = (data, { schema, maps }) => {
+  if (schema.source !== "internal_stories" || !Array.isArray(data)) {
+    return data;
+  }
+  return data.map((d) => maps.stories?.get(d) || d);
+};
+const fieldRefMappers = {
+  asset: assetFieldRefMapper,
+  bloks: bloksFieldRefMapper,
+  multiasset: multiassetFieldRefMapper,
+  multilink: multilinkFieldRefMapper,
+  options: optionsFieldRefMapper,
+  richtext: richtextFieldRefMapper
+};
+const storyRefMapper = (story, { schemas, maps }) => {
+  const processedFields = /* @__PURE__ */ new Set();
+  const missingSchemas = /* @__PURE__ */ new Set();
+  const alternates = story.alternates ? story.alternates.map((a) => ({
+    ...a,
+    id: maps.stories?.get(a.id) || a.id,
+    parent_id: maps.stories?.get(a.parent_id) || a.parent_id
+  })) : story.alternates;
+  const parentId = maps.stories?.get(story.parent_id) || story.parent_id;
+  const mappedStory = {
+    ...story,
+    content: traverseAndMapBySchema(story.content, {
+      schemas,
+      maps,
+      fieldRefMappers,
+      processedFields,
+      missingSchemas
+    }),
+    id: Number(maps.stories?.get(story.id) || story.id),
+    uuid: String(maps.stories?.get(story.uuid) || story.uuid),
+    // @ts-expect-error Our types are wrong.
+    parent_id: parentId ? Number(parentId) : null,
+    alternates
+  };
+  return {
+    mappedStory,
+    processedFields,
+    missingSchemas
+  };
+};
+
+const apiConcurrencyLock = new Sema(12);
+const fetchStoriesStream = ({
+  spaceId,
+  params = {},
+  setTotalStories,
+  setTotalPages,
+  onIncrement,
+  onPageSuccess,
+  onPageError
+}) => {
+  const listGenerator = async function* storyListIterator() {
+    let perPage = 100;
+    let page = 1;
+    let totalPages = 1;
+    setTotalPages?.(totalPages);
+    while (page <= totalPages) {
+      try {
+        const result = await fetchStories(spaceId, {
+          ...params,
+          per_page: perPage,
+          page
+        });
+        if (!result) {
+          break;
+        }
+        const { headers } = result;
+        const total = Number(headers.get("Total"));
+        perPage = Number(headers.get("Per-Page"));
+        totalPages = Math.ceil(total / perPage);
+        setTotalStories?.(total);
+        setTotalPages?.(totalPages);
+        onPageSuccess?.(page, totalPages);
+        for (const story of result.stories) {
+          yield story;
+        }
+        page += 1;
+      } catch (maybeError) {
+        onPageError?.(toError(maybeError), page, totalPages);
+        break;
+      } finally {
+        onIncrement?.();
+      }
+    }
+  };
+  return Readable.from(listGenerator());
+};
+const fetchStoryStream = ({
+  spaceId,
+  onIncrement,
+  onStorySuccess,
+  onStoryError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Transform({
+    objectMode: true,
+    async transform(listStory, _encoding, callback) {
+      await apiConcurrencyLock.acquire();
+      const task = fetchStory(spaceId, listStory.id.toString()).then((story) => {
+        if (typeof story === "undefined") {
+          throw new TypeError("Invalid story!");
+        }
+        onStorySuccess?.(story);
+        this.push(story);
+      }).catch((maybeError) => {
+        onStoryError?.(toError(maybeError), listStory);
+      }).finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock.release();
+        processing.delete(task);
+      });
+      processing.add(task);
+      callback();
+    },
+    // Ensure all pending requests finish before closing the stream
+    flush(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+const getUUIDFromFilename = (filename) => {
+  const uuid = basename(filename, extname(filename)).split("_").at(-1);
+  if (!uuid) {
+    throw new Error(`Unable to extract UUID from local story "${filename}"`);
+  }
+  return uuid;
+};
+const readLocalStoriesStream = ({
+  directoryPath,
+  fileFilter = () => true,
+  setTotalStories,
+  onIncrement,
+  onStorySuccess,
+  onStoryError
+}) => {
+  const listGenerator = async function* localStoryIterator() {
+    const files = (await readDirectory(directoryPath)).filter((f) => extname(f) === ".json" && fileFilter({ uuid: getUUIDFromFilename(f) }));
+    setTotalStories?.(files.length);
+    for (const file of files) {
+      try {
+        const filePath = join(directoryPath, file);
+        const fileContent = await readFile$1(filePath, "utf-8");
+        const story = JSON.parse(fileContent);
+        onStorySuccess?.(story);
+        yield story;
+      } catch (maybeError) {
+        onStoryError?.(toError(maybeError), file);
+      } finally {
+        onIncrement?.();
+      }
+    }
+  };
+  return Readable.from(listGenerator());
+};
+const mapReferencesStream = ({
+  schemas,
+  maps,
+  onIncrement,
+  onStorySuccess,
+  onStoryError
+}) => {
+  return new Transform({
+    objectMode: true,
+    transform(localStory, _encoding, callback) {
+      try {
+        const { mappedStory, processedFields, missingSchemas } = storyRefMapper(localStory, { schemas, maps });
+        onStorySuccess?.(mappedStory, processedFields, missingSchemas);
+        this.push(mappedStory);
+      } catch (maybeError) {
+        onStoryError?.(toError(maybeError), localStory);
+      } finally {
+        onIncrement?.();
+        callback();
+      }
+    }
+  });
+};
+const getRemoteStory = async ({ spaceId, storyId }) => {
+  const { data, response } = await mapiClient().stories.get({
+    path: {
+      space_id: spaceId,
+      story_id: storyId
+    }
+  });
+  if (!response.ok && response.status !== 404) {
+    handleAPIError("pull_story", new FetchError(response.statusText, response));
+  }
+  if (data?.story?.deleted_at) {
+    return void 0;
+  }
+  return data?.story;
+};
+const makeCreateStoryAPITransport = ({ spaceId }) => async (localStory) => {
+  const { id: _id, uuid: _uuid, content, parent_id: _p, ...newStoryData } = localStory;
+  const remoteStory = await createStory(spaceId, {
+    story: {
+      ...newStoryData,
+      content: {
+        // @ts-expect-error Our types are wrong.
+        component: content?.component
+      }
+    },
+    publish: 0
+  });
+  if (!remoteStory) {
+    throw new Error("No response!");
+  }
+  return remoteStory;
+};
+const makeAppendToManifestFSTransport = ({ manifestFile }) => async (localStory, remoteStory) => {
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  await appendToFile(manifestFile, JSON.stringify({
+    old_id: localStory.uuid,
+    new_id: remoteStory.uuid,
+    created_at: createdAt
+  }));
+  await appendToFile(manifestFile, JSON.stringify({
+    old_id: localStory.id,
+    new_id: remoteStory.id,
+    created_at: createdAt
+  }));
+};
+const createStoryPlaceholderStream = ({
+  maps,
+  spaceId,
+  transports,
+  onIncrement,
+  onStorySuccess,
+  onStorySkipped,
+  onStoryError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Writable({
+    objectMode: true,
+    async write(localStory, _encoding, callback) {
+      await apiConcurrencyLock.acquire();
+      const task = (async () => {
+        try {
+          const mappedStoryId = maps.stories?.get(localStory.id);
+          const mappedRemoteStory = mappedStoryId && await getRemoteStory({ spaceId, storyId: Number(mappedStoryId) });
+          if (mappedRemoteStory) {
+            onStorySkipped?.(localStory, mappedRemoteStory);
+            return;
+          }
+          const existingRemoteStory = await getRemoteStory({ spaceId, storyId: localStory.id });
+          if (existingRemoteStory && existingRemoteStory.uuid === localStory.uuid) {
+            await transports.appendStoryManifest(localStory, existingRemoteStory);
+            onStorySkipped?.(localStory, existingRemoteStory);
+            return;
+          }
+          const newRemoteStory = await transports.createStory(localStory);
+          await transports.appendStoryManifest(localStory, newRemoteStory);
+          onStorySuccess?.(localStory, newRemoteStory);
+        } catch (maybeError) {
+          onStoryError?.(toError(maybeError), localStory);
+        }
+      })();
+      processing.add(task);
+      task.finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock.release();
+        processing.delete(task);
+      });
+      callback();
+    },
+    final(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+const makeWriteStoryFSTransport = ({ directoryPath }) => async (story) => {
+  await saveToFile(resolve$1(directoryPath, getStoryFilename(story)), JSON.stringify(story, null, 2));
+  return story;
+};
+const makeWriteStoryAPITransport = ({ spaceId, publish }) => (mappedLocalStory) => updateStory(spaceId, mappedLocalStory.id, {
+  story: mappedLocalStory,
+  publish: publish ?? (mappedLocalStory.published ? 1 : 0)
+});
+const makeCleanupStoryFSTransport = ({ directoryPath, maps }) => async (mappedStory) => {
+  const mapEntry = maps.stories?.entries().find(([_, v]) => v === mappedStory.uuid);
+  const originalUuid = mapEntry?.[0] && typeof mapEntry?.[0] === "string" ? mapEntry?.[0] : mappedStory.uuid;
+  const storyFilename = getStoryFilename({
+    slug: mappedStory.slug,
+    uuid: originalUuid
+  });
+  const storyFilePath = resolve$1(directoryPath, storyFilename);
+  await unlink(storyFilePath);
+};
+const writeStoryStream = ({
+  transports,
+  onIncrement,
+  onStorySuccess,
+  onStoryError
+}) => {
+  const processing = /* @__PURE__ */ new Set();
+  return new Writable({
+    objectMode: true,
+    async write(mappedLocalStory, _encoding, callback) {
+      await apiConcurrencyLock.acquire();
+      const task = (async () => {
+        try {
+          const remoteStory = await transports.writeStory(mappedLocalStory);
+          await transports.cleanupStory?.(remoteStory);
+          onStorySuccess?.(mappedLocalStory, remoteStory);
+        } catch (maybeError) {
+          onStoryError?.(toError(maybeError), mappedLocalStory);
+        }
+      })();
+      processing.add(task);
+      task.finally(() => {
+        onIncrement?.();
+        apiConcurrencyLock.release();
+        processing.delete(task);
+      });
+      callback();
+    },
+    final(callback) {
+      Promise.all(processing).finally(() => callback());
+    }
+  });
+};
+
+const PROGRESS_BAR_PADDING = 23;
+const upsertAssetFoldersPipeline = async ({
+  directoryPath,
+  logger,
+  maps,
+  transports,
+  ui
+}) => {
+  const folderProgress = ui.createProgressBar({ title: "Folders...".padEnd(PROGRESS_BAR_PADDING) });
+  const summary = { total: 0, succeeded: 0, failed: 0 };
+  await pipeline$1(
+    readLocalAssetFoldersStream({
+      directoryPath,
+      setTotalFolders: (total) => {
+        summary.total = total;
+        folderProgress.setTotal(total);
+      },
+      onFolderError: (error) => {
+        summary.failed += 1;
+        logOnlyError(error);
+      }
+    }),
+    upsertAssetFolderStream({
+      transports,
+      maps,
+      onIncrement: () => folderProgress.increment(),
+      onFolderSuccess: (localFolder, remoteFolder) => {
+        summary.succeeded += 1;
+        maps.assetFolders.set(localFolder.id, remoteFolder.id);
+        logger.info("Created asset folder", { folderId: remoteFolder.id });
+      },
+      onFolderError: (error, folder) => {
+        summary.failed += 1;
+        logOnlyError(error, { folderId: folder.id });
+      }
+    })
+  );
+  return [["assetFolderResults", summary]];
+};
+const upsertAssetsPipeline = async ({
+  assetBinaryPath,
+  assetData,
+  directoryPath,
+  logger,
+  maps,
+  transports,
+  ui
+}) => {
+  const assetProgress = ui.createProgressBar({ title: "Assets...".padEnd(PROGRESS_BAR_PADDING) });
+  const summary = { total: 0, succeeded: 0, failed: 0, skipped: 0 };
+  const steps = [];
+  if (assetBinaryPath && assetData) {
+    summary.total = 1;
+    assetProgress.setTotal(1);
+    steps.push(readSingleAssetStream({
+      asset: assetData,
+      assetBinaryPath,
+      onAssetError: (error) => {
+        summary.failed += 1;
+        assetProgress.increment();
+        logOnlyError(error);
+      }
+    }));
+  } else {
+    steps.push(readLocalAssetsStream({
+      directoryPath,
+      setTotalAssets: (total) => {
+        summary.total = total;
+        assetProgress.setTotal(total);
+      },
+      onAssetError: (error) => {
+        summary.failed += 1;
+        assetProgress.increment();
+        logOnlyError(error);
+      }
+    }));
+  }
+  steps.push(upsertAssetStream({
+    transports,
+    maps,
+    onIncrement: () => assetProgress.increment(),
+    onAssetSuccess: (localAssetResult, remoteAsset) => {
+      if ("id" in localAssetResult && localAssetResult.id) {
+        maps.assets.set(localAssetResult.id, {
+          old: localAssetResult,
+          new: {
+            id: remoteAsset.id,
+            filename: remoteAsset.filename,
+            meta_data: remoteAsset.meta_data
+          }
+        });
+      }
+      summary.succeeded += 1;
+      logger.info("Uploaded asset", { assetId: remoteAsset.id });
+    },
+    onAssetSkipped: (localAssetResult, remoteAsset) => {
+      if ("id" in localAssetResult && localAssetResult.id) {
+        maps.assets.set(localAssetResult.id, {
+          old: localAssetResult,
+          new: {
+            id: remoteAsset.id,
+            filename: remoteAsset.filename,
+            meta_data: remoteAsset.meta_data
+          }
+        });
+      }
+      summary.skipped += 1;
+      logger.debug("Skipped asset (unchanged)", { assetId: remoteAsset.id });
+    },
+    onAssetError: (error, asset) => {
+      summary.failed += 1;
+      logOnlyError(error, { assetId: asset.id });
+    }
+  }));
+  await pipeline$1(steps);
+  return [["assetResults", summary]];
+};
+const mapAssetReferencesInStoriesPipeline = async ({
+  logger,
+  maps,
+  schemas,
+  space,
+  transports,
+  ui
+}) => {
+  if (Object.keys(schemas).length === 0) {
+    const message = "No components found. Please run `storyblok components pull` to fetch the latest components.";
+    ui.error(message);
+    logger.error(message);
+    return [];
+  }
+  const fetchStoryPagesProgress = ui.createProgressBar({ title: "Fetching Story Pages...".padEnd(PROGRESS_BAR_PADDING) });
+  const fetchStoriesProgress = ui.createProgressBar({ title: "Fetching Stories...".padEnd(PROGRESS_BAR_PADDING) });
+  const processProgress = ui.createProgressBar({ title: "Processing Stories...".padEnd(PROGRESS_BAR_PADDING) });
+  const updateProgress = ui.createProgressBar({ title: "Updating Stories...".padEnd(PROGRESS_BAR_PADDING) });
+  const summaries = {
+    fetchStoryPages: { total: 0, succeeded: 0, failed: 0 },
+    fetchStories: { total: 0, succeeded: 0, failed: 0 },
+    storyProcessResults: { total: 0, succeeded: 0, failed: 0 },
+    storyUpdateResults: { total: 0, succeeded: 0, failed: 0 }
+  };
+  const warnAboutMissingSchemas = (missingSchemas, story) => {
+    const missingSchemaWarnings = /* @__PURE__ */ new Set();
+    for (const schemaName of missingSchemas) {
+      if (missingSchemaWarnings.has(schemaName)) {
+        continue;
+      }
+      const message = `The component "${schemaName}" was not found. Please run \`storyblok components pull\` to fetch the latest components.`;
+      logger.warn(message, { storyId: story.uuid });
+      missingSchemaWarnings.add(schemaName);
+    }
+  };
+  const assetMapValues = [...maps.assets.values()];
+  const reference_search = assetMapValues.length === 1 ? assetMapValues[0].new.filename : void 0;
+  await pipeline$1(
+    fetchStoriesStream({
+      spaceId: space,
+      params: {
+        reference_search
+      },
+      setTotalPages: (totalPages) => {
+        summaries.fetchStoryPages.total = totalPages;
+        fetchStoryPagesProgress.setTotal(totalPages);
+      },
+      setTotalStories: (total) => {
+        summaries.fetchStories.total = total;
+        summaries.storyProcessResults.total = total;
+        summaries.storyUpdateResults.total = total;
+        fetchStoriesProgress.setTotal(total);
+        processProgress.setTotal(total);
+        updateProgress.setTotal(total);
+      },
+      onIncrement: () => fetchStoryPagesProgress.increment(),
+      onPageSuccess: (page, total) => {
+        logger.info(`Fetched stories page ${page} of ${total}`);
+        summaries.fetchStoryPages.succeeded += 1;
+      },
+      onPageError: (error, page, total) => {
+        summaries.fetchStoryPages.failed += 1;
+        logOnlyError(error, { page, total });
+      }
+    }),
+    fetchStoryStream({
+      spaceId: space,
+      onIncrement: () => {
+        fetchStoriesProgress.increment();
+      },
+      onStorySuccess: (story) => {
+        logger.info("Fetched story", { storyId: story.id });
+        summaries.fetchStories.succeeded += 1;
+      },
+      onStoryError: (error, story) => {
+        summaries.fetchStories.failed += 1;
+        summaries.storyProcessResults.total -= 1;
+        summaries.storyUpdateResults.total -= 1;
+        processProgress.setTotal(summaries.storyProcessResults.total);
+        updateProgress.setTotal(summaries.storyProcessResults.total);
+        logOnlyError(error, { storyId: story.id });
+      }
+    }),
+    // Map all references to numeric ids and uuids.
+    mapReferencesStream({
+      schemas,
+      maps: { stories: /* @__PURE__ */ new Map(), ...maps },
+      onIncrement() {
+        processProgress.increment();
+      },
+      onStorySuccess(localStory, _, missingSchemas) {
+        warnAboutMissingSchemas(missingSchemas, localStory);
+        logger.info("Processed story", { storyId: localStory.uuid });
+        summaries.storyProcessResults.succeeded += 1;
+      },
+      onStoryError(error, localStory) {
+        summaries.storyProcessResults.failed += 1;
+        summaries.storyUpdateResults.total -= 1;
+        updateProgress.setTotal(summaries.storyUpdateResults.total);
+        logOnlyError(error, { storyId: localStory.id });
+      }
+    }),
+    // Update remote stories with correct references.
+    writeStoryStream({
+      transports: {
+        writeStory: transports.writeStory
+      },
+      onIncrement() {
+        updateProgress.increment();
+      },
+      onStorySuccess(localStory) {
+        logger.info("Updated story", { storyId: localStory.uuid });
+        summaries.storyUpdateResults.succeeded += 1;
+      },
+      onStoryError(error, localStory) {
+        summaries.storyUpdateResults.failed += 1;
+        logOnlyError(error, { storyId: localStory.id });
+      }
+    })
+  );
+  return Object.entries(summaries);
+};
+
+assetsCommand.command("push").argument("[asset]", "path or URL of a single asset to push").option("-f, --from <from>", "source space id").option("--data <data>", "inline asset data as JSON").option("--short-filename <short-filename>", "override the asset filename").option("--folder <folderId>", "destination asset folder ID").option("--cleanup", "delete local assets and metadata after a successful push (note: does not cleanup manifests)").option("--update-stories", "update file references in stories if necessary", false).option("--asset-token <token>", "asset token for accessing private assets").option("-d, --dry-run", "Preview changes without applying them to Storyblok").description(`Push local assets to a Storyblok space.`).action(async (assetInput, options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  ui.title(`${commands.ASSETS}`, colorPalette.ASSETS, "Pushing assets...");
+  logger.info("Pushing assets started");
+  if (options.dryRun) {
+    ui.warn(`DRY RUN MODE ENABLED: No changes will be made.
+`);
+    logger.warn("Dry run mode enabled");
+  }
+  const { space: targetSpace, path: basePath, verbose } = command.optsWithGlobals();
+  const fromSpace = options.from || targetSpace;
+  const assetToken = options.assetToken;
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    process.exitCode = 2;
+    return;
+  }
+  if (!targetSpace) {
+    handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
+    process.exitCode = 2;
+    return;
+  }
+  const { password, region } = state;
+  mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
+  const summaries = [];
+  let fatalError = false;
+  const manifestFile = join(resolveCommandPath(directories.assets, fromSpace, basePath), "manifest.jsonl");
+  const folderManifestFile = join(resolveCommandPath(directories.assets, fromSpace, basePath), "folders", "manifest.jsonl");
+  try {
+    const [assetMap, assetFolderMap] = await Promise.all([
+      loadAssetMap(manifestFile),
+      loadAssetFolderMap(folderManifestFile)
+    ]);
+    const maps = { assets: assetMap, assetFolders: assetFolderMap };
+    const assetsDirectoryPath = resolveCommandPath(directories.assets, fromSpace, basePath);
+    const assetFolderGetTransport = makeGetAssetFolderAPITransport({ spaceId: targetSpace });
+    const assetFolderCreateTransport = options.dryRun ? async (folder) => folder : makeCreateAssetFolderAPITransport({ spaceId: targetSpace });
+    const assetFolderUpdateTransport = options.dryRun ? async (folder) => folder : makeUpdateAssetFolderAPITransport({ spaceId: targetSpace });
+    const assetFolderManifestTransport = options.dryRun ? () => Promise.resolve() : makeAppendAssetFolderManifestFSTransport({ manifestFile: folderManifestFile });
+    const cleanupAssetFolderTransport = options.cleanup && !options.dryRun ? makeCleanupAssetFolderFSTransport() : () => Promise.resolve();
+    summaries.push(...await upsertAssetFoldersPipeline({
+      directoryPath: join(assetsDirectoryPath, "folders"),
+      logger,
+      maps,
+      transports: {
+        getAssetFolder: assetFolderGetTransport,
+        createAssetFolder: assetFolderCreateTransport,
+        updateAssetFolder: assetFolderUpdateTransport,
+        appendAssetFolderManifest: assetFolderManifestTransport,
+        cleanupAssetFolder: cleanupAssetFolderTransport
+      },
+      ui
+    }));
+    const assetBinaryPath = typeof assetInput === "string" && assetInput.trim().length > 0 ? assetInput : void 0;
+    let assetData;
+    if (assetBinaryPath) {
+      const assetDataPartial = options.data ? parseAssetData(options.data) : !isRemoteSource(assetBinaryPath) ? await loadSidecarAssetData(assetBinaryPath) : {};
+      const sourceBasename = isRemoteSource(assetBinaryPath) ? basename(new URL(assetBinaryPath).pathname) : basename(assetBinaryPath);
+      const shortFilename = options.shortFilename || assetDataPartial.short_filename || sourceBasename;
+      const folderId = options.folder ? Number(options.folder) : void 0;
+      assetData = {
+        ...assetDataPartial,
+        short_filename: shortFilename,
+        asset_folder_id: folderId
+      };
+    }
+    const getAssetTransport = makeGetAssetAPITransport({ spaceId: targetSpace });
+    const createAssetTransport = options.dryRun ? async (asset) => asset : makeCreateAssetAPITransport({ spaceId: targetSpace });
+    const updateAssetTransport = options.dryRun ? async (asset) => asset : makeUpdateAssetAPITransport({ spaceId: targetSpace });
+    const downloadAssetFileTransport = makeDownloadAssetFileTransport({
+      assetToken,
+      region
+    });
+    const assetManifestTransport = options.dryRun ? () => Promise.resolve() : makeAppendAssetManifestFSTransport({ manifestFile });
+    const cleanupAssetTransport = options.cleanup && !options.dryRun ? makeCleanupAssetFSTransport() : () => Promise.resolve();
+    summaries.push(...await upsertAssetsPipeline({
+      assetBinaryPath,
+      assetData,
+      directoryPath: assetsDirectoryPath,
+      logger,
+      maps,
+      transports: {
+        getAsset: getAssetTransport,
+        createAsset: createAssetTransport,
+        updateAsset: updateAssetTransport,
+        downloadAssetFile: downloadAssetFileTransport,
+        appendAssetManifest: assetManifestTransport,
+        cleanupAsset: cleanupAssetTransport
+      },
+      ui
+    }));
+    const hasUpdatedFilename = (entry) => "filename" in entry.old && entry.old.filename !== entry.new.filename;
+    const hasMetadata = (entry) => "meta_data" in entry.new && entry.new.meta_data;
+    const hasUpdatedAssets = maps.assets.values().some((v) => hasUpdatedFilename(v) || hasMetadata(v));
+    if (hasUpdatedAssets && options.updateStories) {
+      const schemas = await findComponentSchemas(resolveCommandPath(directories.components, fromSpace, basePath));
+      const writeStoryTransport = options.dryRun ? async (story) => story : makeWriteStoryAPITransport({ spaceId: targetSpace });
+      summaries.push(...await mapAssetReferencesInStoriesPipeline({
+        logger,
+        maps,
+        schemas,
+        space: targetSpace,
+        transports: {
+          writeStory: writeStoryTransport
+        },
+        ui
+      }));
+    }
+    if (!options.dryRun) {
+      await deduplicateManifest(manifestFile);
+    }
+  } catch (maybeError) {
+    fatalError = true;
+    handleError(toError(maybeError), verbose);
+  } finally {
+    ui.stopAllProgressBars();
+    const summary = Object.fromEntries(summaries);
+    logger.info("Pushing assets finished", { summary });
+    const assetsTotal = summary.assetResults?.total ?? 0;
+    const assetsSucceeded = summary.assetResults?.succeeded ?? 0;
+    const assetsSkipped = summary.assetResults?.skipped ?? 0;
+    const assetsFailed = summary.assetResults?.failed ?? 0;
+    ui.info(`Push results: ${assetsTotal} processed, ${assetsFailed} assets failed`);
+    ui.list([
+      `Folders: ${summary.assetFolderResults?.succeeded ?? 0}/${summary.assetFolderResults?.total ?? 0} succeeded, ${summary.assetFolderResults?.failed ?? 0} failed.`,
+      `Assets: ${assetsSucceeded}/${assetsTotal} succeeded, ${assetsSkipped} skipped, ${assetsFailed} failed.`
+    ]);
+    for (const [name, reportSummary] of summaries) {
+      reporter.addSummary(name, reportSummary);
+    }
+    reporter.finalize();
+    const failedTotal = Object.values(summary).reduce((total, entry) => {
+      if (!entry || typeof entry.failed !== "number") {
+        return total;
+      }
+      return total + entry.failed;
+    }, 0);
+    process.exitCode = fatalError ? 2 : failedTotal > 0 ? 1 : 0;
+  }
+});
+
+const program$1 = getProgram();
+const storiesCommand = program$1.command(commands.STORIES).description(`Manage your space's stories`).option("-s, --space <space>", "space ID");
+
+storiesCommand.command("pull").option("-d, --dry-run", "Preview changes without applying them to Storyblok").option("-p, --path <path>", "base path to store stories (default .storyblok)").option("-q, --query <query>", 'Filter stories by content attributes using Storyblok filter query syntax. Example: --query="[highlighted][in]=true"').option("--starts-with <path>", 'Filter stories by path. Example: --starts-with="/en/blog/"').description(`Download your space's stories as separate json files.`).action(async (options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  ui.title(`${commands.STORIES}`, colorPalette.STORIES, "Pulling stories...");
+  logger.info("Pulling stories started");
+  if (options.dryRun) {
+    ui.warn(`DRY RUN MODE ENABLED: No changes will be made.
+`);
+    logger.warn("Dry run mode enabled");
+  }
+  const { space, path: basePath, verbose } = command.optsWithGlobals();
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
+    return;
+  }
+  const { password, region } = state;
+  mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
+  const summary = {
+    fetchStoryPages: { total: 0, succeeded: 0, failed: 0 },
+    fetchStories: { total: 0, succeeded: 0, failed: 0 },
+    save: { total: 0, succeeded: 0, failed: 0 }
+  };
+  try {
+    const fetchStoryPagesProgress = ui.createProgressBar({ title: "Fetching Story Pages...".padEnd(23) });
+    const fetchStoriesProgress = ui.createProgressBar({ title: "Fetching Stories...".padEnd(23) });
+    const saveProgress = ui.createProgressBar({ title: "Saving Stories...".padEnd(23) });
+    await pipeline$1(
+      fetchStoriesStream({
+        spaceId: space,
+        params: {
+          filter_query: options.query,
+          starts_with: options.startsWith
+        },
+        setTotalPages: (totalPages) => {
+          summary.fetchStoryPages.total = totalPages;
+          fetchStoryPagesProgress.setTotal(totalPages);
+        },
+        setTotalStories: (total) => {
+          summary.fetchStories.total = total;
+          summary.save.total = total;
+          fetchStoriesProgress.setTotal(total);
+          saveProgress.setTotal(total);
+        },
+        onIncrement: () => {
+          fetchStoryPagesProgress.increment();
+        },
+        onPageSuccess: (page, total) => {
+          logger.info(`Fetched stories page ${page} of ${total}`);
+          summary.fetchStoryPages.succeeded += 1;
+        },
+        onPageError: (error, page, total) => {
+          summary.fetchStoryPages.failed += 1;
+          handleError(error, verbose, { page, total });
+        }
+      }),
+      fetchStoryStream({
+        spaceId: space,
+        onIncrement: () => {
+          fetchStoriesProgress.increment();
+        },
+        onStorySuccess: (story) => {
+          logger.info("Fetched story", { storyId: story.id });
+          summary.fetchStories.succeeded += 1;
+        },
+        onStoryError: (error, story) => {
+          summary.fetchStories.failed += 1;
+          summary.save.total -= 1;
+          saveProgress.setTotal(summary.save.total);
+          handleError(error, verbose, { storyId: story.id });
+        }
+      }),
+      writeStoryStream({
+        transports: {
+          writeStory: options.dryRun ? async (story) => story : makeWriteStoryFSTransport({ directoryPath: resolveCommandPath(directories.stories, space, basePath) })
+        },
+        onIncrement: () => {
+          saveProgress.increment();
+        },
+        onStorySuccess: (story) => {
+          logger.info("Saved story", { storyId: story.id });
+          summary.save.succeeded += 1;
+        },
+        onStoryError: (error, story) => {
+          summary.save.failed += 1;
+          handleError(error, verbose, { storyId: story.id });
+        }
+      })
+    );
+  } catch (maybeError) {
+    handleError(toError(maybeError));
+  } finally {
+    logger.info("Pulling stories finished", summary);
+    ui.stopAllProgressBars();
+    ui.info(`Pull results: ${summary.save.total} stories pulled, ${Math.max(summary.fetchStories.failed, summary.save.failed)} stories failed`);
+    ui.list([
+      `Fetching pages: ${summary.fetchStoryPages.succeeded}/${summary.fetchStoryPages.total} succeeded, ${summary.fetchStoryPages.failed} failed.`,
+      `Fetching stories: ${summary.fetchStories.succeeded}/${summary.fetchStories.total} succeeded, ${summary.fetchStories.failed} failed.`,
+      `Saving stories: ${summary.save.succeeded}/${summary.save.total} succeeded, ${summary.save.failed} failed.`
+    ]);
+    reporter.addSummary("fetchStoryPagesResults", summary.fetchStoryPages);
+    reporter.addSummary("fetchStoriesResults", summary.fetchStories);
+    reporter.addSummary("saveResults", summary.save);
+    reporter.finalize();
+  }
+});
+
+storiesCommand.command("push").option("-f, --from <from>", "source space id").option("-p, --path <path>", "base path for stories and components (default .storyblok)").option("-d, --dry-run", "Preview changes without applying them to Storyblok").option("--publish", "Publish stories after pushing").option("--cleanup", "delete local stories after a successful push (note: does not cleanup manifests)").description(`Push local stories to a Storyblok space.`).action(async (options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  ui.title(`${commands.STORIES}`, colorPalette.STORIES, "Pushing stories...");
+  logger.info("Pushing stories started");
+  if (options.dryRun) {
+    ui.warn(`DRY RUN MODE ENABLED: No changes will be made.
+`);
+    logger.warn("Dry run mode enabled");
+  }
+  const { space, path: basePath, verbose } = command.optsWithGlobals();
+  const fromSpace = options.from || space;
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
+    return;
+  }
+  const { password, region } = state;
+  mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
+  const warnAboutCustomPlugins = (fields, story) => {
+    const warnedPlugins = /* @__PURE__ */ new Set();
+    for (const field of fields) {
+      if (field.type === "custom" && typeof field.field_type === "string") {
+        if (warnedPlugins.has(field.field_type)) {
+          continue;
+        }
+        warnedPlugins.add(field.field_type);
+        const message = `The custom plugin "${field.field_type}" may contain references that require manual updates.`;
+        ui.warn(message);
+        logger.warn(message, { storyId: story.uuid });
+      }
+    }
+  };
+  const warnAboutMissingSchemas = (missingSchemas, story) => {
+    const missingSchemaWarnings = /* @__PURE__ */ new Set();
+    for (const schemaName of missingSchemas) {
+      if (missingSchemaWarnings.has(schemaName)) {
+        continue;
+      }
+      const message = `The component "${schemaName}" was not found. Please run \`storyblok components pull\` to fetch the latest components.`;
+      ui.warn(message);
+      logger.warn(message, { storyId: story.uuid });
+      missingSchemaWarnings.add(schemaName);
+    }
+  };
+  const summary = {
+    creationResults: { total: 0, succeeded: 0, skipped: 0, failed: 0 },
+    processResults: { total: 0, succeeded: 0, failed: 0 },
+    updateResults: { total: 0, succeeded: 0, failed: 0 }
+  };
+  try {
+    const manifestFile = join(resolveCommandPath(directories.stories, fromSpace, basePath), "manifest.jsonl");
+    const manifest = await loadManifest(manifestFile);
+    const assetManifestFile = join(resolveCommandPath(directories.assets, fromSpace, basePath), "manifest.jsonl");
+    const maps = {
+      assets: await loadAssetMap(assetManifestFile),
+      stories: new Map(manifest.map((e) => [e.old_id, e.new_id]))
+    };
+    const schemas = await findComponentSchemas(resolveCommandPath(directories.components, fromSpace, basePath));
+    if (Object.keys(schemas).length === 0) {
+      const message = "No components found. Please run `storyblok components pull` to fetch the latest components.";
+      ui.error(message);
+      logger.error(message);
+      return;
+    }
+    const storiesDirectoryPath = resolveCommandPath(directories.stories, fromSpace, basePath);
+    const creationProgress = ui.createProgressBar({ title: "Creating Stories...".padEnd(21) });
+    const processProgress = ui.createProgressBar({ title: "Processing Stories...".padEnd(21) });
+    const updateProgress = ui.createProgressBar({ title: "Updating Stories...".padEnd(21) });
+    await pipeline$1(
+      // Read local stories from `.json` files.
+      readLocalStoriesStream({
+        directoryPath: storiesDirectoryPath,
+        setTotalStories(total) {
+          summary.creationResults.total = total;
+          summary.processResults.total = total;
+          summary.updateResults.total = total;
+          creationProgress.setTotal(total);
+          processProgress.setTotal(total);
+          updateProgress.setTotal(total);
+        },
+        onStoryError(error) {
+          summary.creationResults.failed += 1;
+          summary.processResults.total -= 1;
+          summary.updateResults.total -= 1;
+          processProgress.setTotal(summary.processResults.total);
+          updateProgress.setTotal(summary.updateResults.total);
+          creationProgress.increment();
+          handleError(error, verbose);
+        }
+      }),
+      // Create remote stories.
+      createStoryPlaceholderStream({
+        maps,
+        spaceId: space,
+        transports: {
+          createStory: options.dryRun ? async (story) => story : makeCreateStoryAPITransport({
+            maps,
+            spaceId: space
+          }),
+          appendStoryManifest: options.dryRun ? () => Promise.resolve() : makeAppendToManifestFSTransport({
+            manifestFile
+          })
+        },
+        onStorySuccess(localStory, remoteStory) {
+          if (!localStory.uuid || !remoteStory.uuid) {
+            throw new Error("Invalid story provided!");
+          }
+          maps.stories.set(localStory.id, remoteStory.id);
+          maps.stories.set(localStory.uuid, remoteStory.uuid);
+          logger.info("Created story", { storyId: remoteStory.uuid });
+          summary.creationResults.succeeded += 1;
+        },
+        onStorySkipped(localStory, remoteStory) {
+          if (!localStory.uuid || !remoteStory.uuid) {
+            throw new Error("Invalid story provided!");
+          }
+          maps.stories.set(localStory.id, remoteStory.id);
+          maps.stories.set(localStory.uuid, remoteStory.uuid);
+          logger.info("Skipped creating story", { storyId: localStory.uuid });
+          summary.creationResults.skipped += 1;
+        },
+        onStoryError(error) {
+          summary.creationResults.failed += 1;
+          summary.processResults.total -= 1;
+          summary.updateResults.total -= 1;
+          processProgress.setTotal(summary.processResults.total);
+          updateProgress.setTotal(summary.updateResults.total);
+          handleError(error, verbose);
+        },
+        onIncrement() {
+          creationProgress.increment();
+        }
+      })
+    );
+    await pipeline$1(
+      // Read local stories from `.json` files.
+      readLocalStoriesStream({
+        directoryPath: storiesDirectoryPath,
+        fileFilter({ uuid }) {
+          return Boolean(maps.stories.get(uuid));
+        },
+        setTotalStories(total) {
+          summary.processResults.total = total;
+          summary.updateResults.total = total;
+          processProgress.setTotal(total);
+          updateProgress.setTotal(total);
+        },
+        onStoryError(error) {
+          summary.creationResults.failed += 1;
+          summary.processResults.total -= 1;
+          summary.updateResults.total -= 1;
+          processProgress.setTotal(summary.processResults.total);
+          updateProgress.setTotal(summary.updateResults.total);
+          handleError(error, verbose);
+        }
+      }),
+      // Map all references to numeric ids and uuids.
+      mapReferencesStream({
+        schemas,
+        maps,
+        onIncrement() {
+          processProgress.increment();
+        },
+        onStorySuccess(localStory, processedFields, missingSchemas) {
+          warnAboutCustomPlugins(processedFields, localStory);
+          warnAboutMissingSchemas(missingSchemas, localStory);
+          logger.info("Processed story", { storyId: localStory.uuid });
+          summary.processResults.succeeded += 1;
+        },
+        onStoryError(error, localStory) {
+          summary.processResults.failed += 1;
+          summary.updateResults.total -= 1;
+          updateProgress.setTotal(summary.updateResults.total);
+          handleError(error, verbose, { storyId: localStory.uuid });
+        }
+      }),
+      // Update remote stories with correct references.
+      writeStoryStream({
+        transports: {
+          writeStory: options.dryRun ? async (story) => story : makeWriteStoryAPITransport({
+            spaceId: space,
+            publish: options.publish ? 1 : void 0
+          }),
+          cleanupStory: options.cleanup && !options.dryRun ? makeCleanupStoryFSTransport({ directoryPath: storiesDirectoryPath, maps }) : void 0
+        },
+        onIncrement() {
+          updateProgress.increment();
+        },
+        onStorySuccess(localStory) {
+          logger.info("Updated story", { storyId: localStory.uuid });
+          summary.updateResults.succeeded += 1;
+        },
+        onStoryError(error, localStory) {
+          summary.updateResults.failed += 1;
+          handleError(error, verbose, { storyId: localStory.uuid });
+        }
+      })
+    );
+  } catch (maybeError) {
+    handleError(toError(maybeError));
+  } finally {
+    logger.info("Pushing stories finished", summary);
+    ui.stopAllProgressBars();
+    const failedStories = Math.max(summary.creationResults.failed, summary.processResults.failed, summary.updateResults.failed);
+    ui.info(`Push results: ${summary.creationResults.total} ${summary.creationResults.total === 1 ? "story" : "stories"} pushed, ${failedStories} ${failedStories === 1 ? "story" : "stories"} failed`);
+    ui.list([
+      `Creating stories: ${summary.creationResults.succeeded + summary.creationResults.skipped}/${summary.creationResults.total} succeeded, ${summary.creationResults.failed} failed.`,
+      `Processing stories: ${summary.processResults.succeeded}/${summary.processResults.total} succeeded, ${summary.processResults.failed} failed.`,
+      `Updating stories: ${summary.updateResults.succeeded}/${summary.updateResults.total} succeeded, ${summary.updateResults.failed} failed.`
+    ]);
+    reporter.addSummary("creationResults", summary.creationResults);
+    reporter.addSummary("processResults", summary.processResults);
+    reporter.addSummary("updateResults", summary.updateResults);
+    reporter.finalize();
+  }
+});
+
 const program = getProgram();
 konsola.br();
 konsola.br();