storyblok 4.0.5 → 4.2.0

package/dist/index.mjs

@@ -6,25 +6,29 @@ import chalk from 'chalk';
 import { Command } from 'commander';
 import { readPackageUp } from 'read-package-up';
 import { Spinner } from '@topcli/spinner';
-import { select, password, input } from '@inquirer/prompts';
-import { mkdir, writeFile, readFile as readFile$1, access, readdir } from 'node:fs/promises';
-import { join, parse, resolve } from 'node:path';
-import { exec } from 'node:child_process';
+import { select, password, input, confirm } from '@inquirer/prompts';
+import fs, { mkdir, writeFile, readFile as readFile$1, access, readdir } from 'node:fs/promises';
+import path, { join, parse, resolve } from 'node:path';
+import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { minimatch } from 'minimatch';
 import { hash } from 'ohash';
 import { compile } from 'json-schema-to-typescript';
 import { readFileSync } from 'node:fs';
+import open from 'open';
+import { Octokit } from 'octokit';
 
 const commands = {
   LOGIN: "login",
   LOGOUT: "logout",
   SIGNUP: "signup",
   USER: "user",
-  COMPONENTS: "Components",
+  COMPONENTS: "components",
   LANGUAGES: "languages",
   MIGRATIONS: "Migrations",
-  TYPES: "Types"
+  TYPES: "Types",
+  DATASOURCES: "Datasources",
+  CREATE: "create"
 };
 const colorPalette = {
   PRIMARY: "#8d60ff",
@@ -36,9 +40,11 @@ const colorPalette = {
   LANGUAGES: "#f5c003",
   MIGRATIONS: "#8CE2FF",
   TYPES: "#3178C6",
+  CREATE: "#ffb3ba",
   GROUPS: "#4ade80",
   TAGS: "#fbbf24",
-  PRESETS: "#a855f7"
+  PRESETS: "#a855f7",
+  DATASOURCES: "#4ade80"
 };
 const regions = {
   EU: "eu",
@@ -54,6 +60,13 @@ const regionsDomain = {
   ca: "api-ca.storyblok.com",
   ap: "api-ap.storyblok.com"
 };
+const appDomains = {
+  eu: "app.storyblok.com",
+  us: "app-us.storyblok.com",
+  cn: "app.storyblokchina.cn",
+  ca: "app-ca.storyblok.com",
+  ap: "app-ap.storyblok.com"
+};
 const regionNames = {
   eu: "Europe",
   us: "United States",
@@ -159,7 +172,13 @@ const API_ACTIONS = {
   update_component_preset: "Failed to update component preset",
   pull_stories: "Failed to pull stories",
   pull_story: "Failed to pull story",
-  update_story: "Failed to update story"
+  update_story: "Failed to update story",
+  pull_datasources: "Failed to pull datasources",
+  push_datasource: "Failed to push datasource",
+  update_datasource: "Failed to update datasource",
+  delete_datasource: "Failed to delete datasource",
+  create_space: "Failed to create space",
+  fetch_blueprints: "Failed to fetch blueprints from GitHub"
 };
 const API_ERRORS = {
   unauthorized: "The user is not authorized to access the API",
@@ -388,6 +407,9 @@ const toCamelCase = (str) => {
 const capitalize = (str) => {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
+const toHumanReadable = (str) => {
+  return str.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ").replace(/\s+/g, " ").trim();
+};
 function maskToken(token) {
   if (token.length <= 4) {
     return token;
@@ -591,6 +613,18 @@ const resolvePath = (path, folder) => {
 const getComponentNameFromFilename = (filename) => {
   return filename.replace(/\.js$/, "");
 };
+async function readJsonFile(filePath) {
+  try {
+    const content = (await readFile(filePath)).toString();
+    if (!content) {
+      return { data: [] };
+    }
+    const parsed = JSON.parse(content);
+    return { data: Array.isArray(parsed) ? parsed : [parsed] };
+  } catch (error) {
+    return { data: [], error };
+  }
+}
 
 const getCredentials = async (filePath = join(getStoryblokGlobalPath(), "credentials.json")) => {
   try {
@@ -718,7 +752,7 @@ function session() {
   return sessionInstance;
 }
 
-const program$e = getProgram();
+const program$i = getProgram();
 const allRegionsText = Object.values(regions).join(",");
 const loginStrategy = {
   message: "How would you like to login?",
@@ -735,12 +769,12 @@ const loginStrategy = {
     }
   ]
 };
-program$e.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$i.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$e.opts().verbose;
+  const verbose = program$i.opts().verbose;
   const { token, region } = options;
   const { state, updateSession, persistCredentials, initializeSession } = session();
   await initializeSession();
@@ -859,10 +893,10 @@ program$e.command(commands.LOGIN).description("Login to the Storyblok CLI").opti
   konsola.br();
 });
 
-const program$d = getProgram();
-program$d.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
+const program$h = getProgram();
+program$h.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
   konsola.title(` ${commands.LOGOUT} `, colorPalette.LOGOUT);
-  const verbose = program$d.opts().verbose;
+  const verbose = program$h.opts().verbose;
   try {
     const { state, initializeSession } = session();
     await initializeSession();
@@ -910,10 +944,10 @@ async function openSignupInBrowser(url) {
   }
 }
 
-const program$c = getProgram();
-program$c.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
+const program$g = getProgram();
+program$g.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
   konsola.title(` ${commands.SIGNUP} `, colorPalette.SIGNUP);
-  const verbose = program$c.opts().verbose;
+  const verbose = program$g.opts().verbose;
   const { state, initializeSession } = session();
   await initializeSession();
   if (state.isLoggedIn && !state.envLogin) {
@@ -959,8 +993,8 @@ const getUser = async (token, region) => {
   }
 };
 
-const program$b = getProgram();
-program$b.command(commands.USER).description("Get the current user").action(async () => {
+const program$f = getProgram();
+program$f.command(commands.USER).description("Get the current user").action(async () => {
   konsola.title(` ${commands.USER} `, colorPalette.USER);
   const { state, initializeSession } = session();
   await initializeSession();
@@ -985,8 +1019,8 @@ program$b.command(commands.USER).description("Get the current user").action(asyn
   konsola.br();
 });
 
-const program$a = getProgram();
-const componentsCommand = program$a.command("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$e = getProgram();
+const componentsCommand = program$e.command("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");
 
 let instance = null;
 const createMapiClient = (options) => {
@@ -1037,14 +1071,18 @@ const createMapiClient = (options) => {
         ...fetchOptions
       });
       let data;
-      try {
-        data = await res.json();
-      } catch {
-        throw new FetchError("Non-JSON response", {
-          status: res.status,
-          statusText: res.statusText,
-          data: null
-        });
+      if (res.status === 204 || res.headers.get("content-length") === "0") {
+        data = null;
+      } else {
+        try {
+          data = await res.json();
+        } catch {
+          throw new FetchError("Non-JSON response", {
+            status: res.status,
+            statusText: res.statusText,
+            data: null
+          });
+        }
       }
       options?.onResponse?.({
         path,
@@ -1111,11 +1149,15 @@ const createMapiClient = (options) => {
   const put = async (path, fetchOptions) => {
     return request(path, { ...fetchOptions, method: "PUT" });
   };
+  const _delete = async (path, fetchOptions) => {
+    return request(path, { ...fetchOptions, method: "DELETE" });
+  };
   instance = {
     uuid: state.uuid,
     get,
     post,
     put,
+    delete: _delete,
     dispose: () => {
       instance = null;
     }
@@ -1332,20 +1374,8 @@ const upsertComponentInternalTag = async (space, tag, existingId) => {
     return await pushComponentInternalTag(space, tag);
   }
 };
-async function readJsonFile(filePath) {
-  try {
-    const content = (await readFile$1(filePath)).toString();
-    if (!content) {
-      return { data: [] };
-    }
-    const parsed = JSON.parse(content);
-    return { data: Array.isArray(parsed) ? parsed : [parsed] };
-  } catch (error) {
-    return { data: [], error };
-  }
-}
 const readComponentsFiles = async (options) => {
-  const { from, path, separateFiles = false, suffix, space } = options;
+  const { from, path, separateFiles = false, suffix } = options;
   const resolvedPath = resolvePath(path, `components/${from}`);
   try {
     await readdir(resolvedPath);
@@ -1356,7 +1386,7 @@ const readComponentsFiles = async (options) => {
    ${chalk.cyan(`storyblok components pull --space ${from}`)}
 
 2. Then try pushing again:
-   ${chalk.cyan(`storyblok components push --space ${space} --from ${from}`)}`;
+   ${chalk.cyan(`storyblok components push --space <target_space> --from ${from}`)}`;
     throw new FileSystemError(
       "file_not_found",
       "read",
@@ -1365,11 +1395,11 @@ const readComponentsFiles = async (options) => {
     );
   }
   if (separateFiles) {
-    return await readSeparateFiles(resolvedPath, suffix);
+    return await readSeparateFiles$1(resolvedPath, suffix);
   }
-  return await readConsolidatedFiles(resolvedPath, suffix);
+  return await readConsolidatedFiles$1(resolvedPath, suffix);
 };
-async function readSeparateFiles(resolvedPath, suffix) {
+async function readSeparateFiles$1(resolvedPath, suffix) {
   const files = await readdir(resolvedPath);
   const components = [];
   const presets = [];
@@ -1424,7 +1454,7 @@ async function readSeparateFiles(resolvedPath, suffix) {
     internalTags
   };
 }
-async function readConsolidatedFiles(resolvedPath, suffix) {
+async function readConsolidatedFiles$1(resolvedPath, suffix) {
   const componentsPath = join(resolvedPath, suffix ? `components.${suffix}.json` : "components.json");
   const componentsResult = await readJsonFile(componentsPath);
   if (componentsResult.error || !componentsResult.data.length) {
@@ -1448,10 +1478,10 @@ async function readConsolidatedFiles(resolvedPath, suffix) {
   };
 }
 
-const program$9 = getProgram();
+const program$d = 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$9.opts().verbose;
+  const verbose = program$d.opts().verbose;
   const { space, path } = componentsCommand.opts();
   const { separateFiles, suffix, filename = "components" } = options;
   const { state, initializeSession } = session();
@@ -1539,6 +1569,153 @@ componentsCommand.command("pull [componentName]").option("-f, --filename <filena
   }
 });
 
+const pushDatasource = async (space, datasource) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.post(`spaces/${space}/datasources`, {
+      body: JSON.stringify(datasource)
+    });
+    return data.datasource;
+  } catch (error) {
+    handleAPIError("push_datasource", error, `Failed to push datasource ${datasource.name}`);
+  }
+};
+const updateDatasource = async (space, datasourceId, datasource) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.put(`spaces/${space}/datasources/${datasourceId}`, {
+      body: JSON.stringify(datasource)
+    });
+    return data.datasource;
+  } catch (error) {
+    handleAPIError("update_datasource", error, `Failed to update datasource ${datasource.name}`);
+  }
+};
+const upsertDatasource = async (space, datasource, existingId) => {
+  if (existingId) {
+    return await updateDatasource(space, existingId, datasource);
+  } else {
+    return await pushDatasource(space, datasource);
+  }
+};
+const pushDatasourceEntry = async (space, datasourceId, entry) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.post(`spaces/${space}/datasource_entries`, {
+      body: JSON.stringify({
+        datasource_entry: {
+          ...entry,
+          datasource_id: datasourceId
+        }
+      })
+    });
+    return data.datasource_entry;
+  } catch (error) {
+    handleAPIError("push_datasource", error, `Failed to push datasource entry ${entry.name}`);
+  }
+};
+const updateDatasourceEntry = async (space, entryId, entry) => {
+  try {
+    const client = mapiClient();
+    await client.put(`spaces/${space}/datasource_entries/${entryId}`, {
+      body: JSON.stringify({
+        datasource_entry: entry
+      })
+    });
+  } catch (error) {
+    handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
+  }
+};
+const upsertDatasourceEntry = async (space, datasourceId, entry, existingId) => {
+  if (existingId) {
+    await updateDatasourceEntry(space, existingId, entry);
+    return void 0;
+  } else {
+    return await pushDatasourceEntry(space, datasourceId, entry);
+  }
+};
+const readDatasourcesFiles = async (options) => {
+  const { from, path, separateFiles = false, suffix, space } = options;
+  const resolvedPath = resolvePath(path, `datasources/${from}`);
+  try {
+    await readdir(resolvedPath);
+  } catch (error) {
+    const message = `No local datasources found for space ${chalk.bold(from)}. To push datasources, you need to pull them first:
+
+1. Pull the datasources from your source space:
+   ${chalk.cyan(`storyblok datasources pull --space ${from}`)}
+
+2. Then try pushing again:
+   ${chalk.cyan(`storyblok datasources push --space ${space} --from ${from}`)}`;
+    throw new FileSystemError(
+      "file_not_found",
+      "read",
+      error,
+      message
+    );
+  }
+  if (separateFiles) {
+    return await readSeparateFiles(resolvedPath, suffix);
+  }
+  return await readConsolidatedFiles(resolvedPath, suffix);
+};
+async function readSeparateFiles(resolvedPath, suffix) {
+  const files = await readdir(resolvedPath);
+  const datasources = [];
+  const filteredFiles = files.filter((file) => {
+    if (suffix) {
+      return file.endsWith(`.${suffix}.json`);
+    } else {
+      return !/\.\w+\.json$/.test(file);
+    }
+  });
+  for (const file of filteredFiles) {
+    const filePath = join(resolvedPath, file);
+    if (file.endsWith(".json") || file.endsWith(`${suffix}.json`)) {
+      if (file === "datasources.json" || /^datasources\.\w+\.json$/.test(file)) {
+        continue;
+      }
+      const result = await readJsonFile(filePath);
+      if (result.error) {
+        handleFileSystemError("read", result.error);
+        continue;
+      }
+      datasources.push(...result.data);
+    }
+  }
+  return {
+    datasources
+  };
+}
+async function readConsolidatedFiles(resolvedPath, suffix) {
+  const datasourcesPath = join(resolvedPath, suffix ? `datasources.${suffix}.json` : "datasources.json");
+  const datasourcesResult = await readJsonFile(datasourcesPath);
+  if (datasourcesResult.error || !datasourcesResult.data.length) {
+    throw new FileSystemError(
+      "file_not_found",
+      "read",
+      datasourcesResult.error || new Error("Datasources file is empty"),
+      `No datasources found in ${datasourcesPath}. Please make sure you have pulled the datasources first.`
+    );
+  }
+  return {
+    datasources: datasourcesResult.data
+  };
+}
+
+function createStubDatasource(name) {
+  return {
+    id: 0,
+    // Will be set by API
+    name,
+    slug: name,
+    dimensions: [],
+    entries: [],
+    // Empty entries for stub
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 function buildDependencyGraph(context) {
   const { spaceState } = context;
   const graph = { nodes: /* @__PURE__ */ new Map() };
@@ -1550,6 +1727,22 @@ function buildDependencyGraph(context) {
       dependency.dependents.add(dependentId);
     }
   }
+  const referencedDatasources = /* @__PURE__ */ new Set();
+  spaceState.local.components.forEach((component) => {
+    if (component.schema) {
+      const dependencies = collectWhitelistDependencies(component.schema);
+      dependencies.datasourceNames.forEach((datasourceName) => {
+        referencedDatasources.add(datasourceName);
+      });
+    }
+  });
+  referencedDatasources.forEach((datasourceName) => {
+    const nodeId = `datasource:${datasourceName}`;
+    const targetDatasource = spaceState.target.datasources?.get(datasourceName);
+    const stubDatasource = createStubDatasource(datasourceName);
+    const node = new DatasourceNode(nodeId, stubDatasource, targetDatasource);
+    graph.nodes.set(nodeId, node);
+  });
   spaceState.local.internalTags.forEach((tag) => {
     const nodeId = `tag:${tag.id}`;
     const targetTag = spaceState.target.tags.get(tag.name);
@@ -1625,6 +1818,10 @@ function buildDependencyGraph(context) {
         const dependencyId = `component:${componentName}`;
         addDependency(componentId, dependencyId);
       });
+      dependencies.datasourceNames.forEach((datasourceName) => {
+        const datasourceId = `datasource:${datasourceName}`;
+        addDependency(componentId, datasourceId);
+      });
     }
   });
   spaceState.local.presets.forEach((preset) => {
@@ -1641,6 +1838,7 @@ function collectWhitelistDependencies(schema) {
   const groupUuids = /* @__PURE__ */ new Set();
   const tagIds = /* @__PURE__ */ new Set();
   const componentNames = /* @__PURE__ */ new Set();
+  const datasourceNames = /* @__PURE__ */ new Set();
   function traverseField(field) {
     if (field.type === "bloks") {
       if (field.component_group_whitelist && Array.isArray(field.component_group_whitelist)) {
@@ -1653,6 +1851,11 @@ function collectWhitelistDependencies(schema) {
         field.component_whitelist.forEach((name) => componentNames.add(name));
       }
     }
+    if ((field.type === "option" || field.type === "options") && field.source === "internal") {
+      if (field.datasource_slug && typeof field.datasource_slug === "string") {
+        datasourceNames.add(field.datasource_slug);
+      }
+    }
     Object.values(field).forEach((value) => {
       if (Array.isArray(value)) {
         value.forEach((item) => {
@@ -1670,7 +1873,7 @@ function collectWhitelistDependencies(schema) {
       traverseField(field);
     }
   });
-  return { groupUuids, tagIds, componentNames };
+  return { groupUuids, tagIds, componentNames, datasourceNames };
 }
 function detectProblematicCycles(graph) {
   const problematicCycles = [];
@@ -2001,6 +2204,15 @@ class ComponentNode extends GraphNode {
           });
         }
       }
+      if ((resolvedField.type === "option" || resolvedField.type === "options") && resolvedField.source === "internal") {
+        if (resolvedField.datasource_slug && typeof resolvedField.datasource_slug === "string") {
+          const datasourceNodeId = `datasource:${resolvedField.datasource_slug}`;
+          const datasourceNode = graph.nodes.get(datasourceNodeId);
+          if (datasourceNode?.targetData) {
+            resolvedField.datasource_slug = datasourceNode.targetData.resource.slug;
+          }
+        }
+      }
       Object.keys(resolvedField).forEach((key) => {
         if (typeof resolvedField[key] === "object" && resolvedField[key] !== null) {
           resolvedField[key] = resolveField(resolvedField[key]);
@@ -2072,6 +2284,23 @@ class PresetNode {
     };
   }
 }
+class DatasourceNode extends GraphNode {
+  constructor(id, data, targetDatasource) {
+    super(id, "datasource", data.name, data, targetDatasource);
+  }
+  resolveReferences(_graph) {
+  }
+  async upsert(space) {
+    const existingDatasource = this.targetData?.resource;
+    const existingId = existingDatasource?.id;
+    const { entries, ...datasourceDefinition } = this.sourceData;
+    const result = await upsertDatasource(space, datasourceDefinition, existingId);
+    if (!result) {
+      throw new Error(`Failed to upsert datasource ${this.name}`);
+    }
+    return result;
+  }
+}
 
 function collectAllDependencies(components, allComponents, allGroups, allTags) {
   const requiredComponents = /* @__PURE__ */ new Set();
@@ -2472,10 +2701,67 @@ async function pushWithDependencyGraph(space, spaceState, maxConcurrency = 5) {
   return results;
 }
 
-const program$8 = getProgram();
+const fetchDatasourceEntries = async (space, datasourceId) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.get(`spaces/${space}/datasource_entries?datasource_id=${datasourceId}`);
+    return data.datasource_entries;
+  } catch (error) {
+    handleAPIError("pull_datasources", error);
+  }
+};
+const fetchDatasources = async (space) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.get(`spaces/${space}/datasources`);
+    const datasources = data.datasources;
+    const datasourcesWithEntries = await Promise.all(
+      datasources.map(async (ds) => {
+        const entries = await fetchDatasourceEntries(space, ds.id);
+        return { ...ds, entries };
+      })
+    );
+    return datasourcesWithEntries;
+  } catch (error) {
+    handleAPIError("pull_datasources", error);
+  }
+};
+const fetchDatasource = async (space, datasourceName) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.get(`spaces/${space}/datasources?search=${encodeURIComponent(datasourceName)}`);
+    const found = data.datasources?.find((d) => d.name === datasourceName);
+    if (!found) {
+      return void 0;
+    }
+    const entries = await fetchDatasourceEntries(space, found.id);
+    return { ...found, entries };
+  } catch (error) {
+    handleAPIError("pull_datasources", error, `Failed to fetch datasource ${datasourceName}`);
+  }
+};
+const saveDatasourcesToFiles = async (space, datasources, options) => {
+  const { filename = "datasources", suffix, path, separateFiles } = options;
+  const resolvedPath = path ? resolve(process.cwd(), path, "datasources", space) : resolvePath(path, `datasources/${space}`);
+  try {
+    if (separateFiles) {
+      for (const datasource of datasources) {
+        const datasourceFilePath = join(resolvedPath, suffix ? `${datasource.name}.${suffix}.json` : `${datasource.name}.json`);
+        await saveToFile(datasourceFilePath, JSON.stringify(datasource, null, 2));
+      }
+      return;
+    }
+    const datasourcesFilePath = join(resolvedPath, suffix ? `${filename}.${suffix}.json` : `${filename}.json`);
+    await saveToFile(datasourcesFilePath, JSON.stringify(datasources, null, 2));
+  } catch (error) {
+    handleFileSystemError("write", error);
+  }
+};
+
+const program$c = 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").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$8.opts().verbose;
+  const verbose = program$c.opts().verbose;
   const { space, path } = componentsCommand.opts();
   const { from, filter } = options;
   const { state, initializeSession } = session();
@@ -2502,26 +2788,33 @@ componentsCommand.command("push [componentName]").description(`Push your space's
     }
   });
   try {
+    const componentsData = await readComponentsFiles({
+      ...options,
+      path,
+      space
+    });
+    const localData = {
+      ...componentsData,
+      datasources: []
+    };
     const spaceState = {
-      local: await readComponentsFiles({
-        ...options,
-        path,
-        space
-      }),
+      local: localData,
       target: {
         components: /* @__PURE__ */ new Map(),
         groups: /* @__PURE__ */ new Map(),
         tags: /* @__PURE__ */ new Map(),
-        presets: /* @__PURE__ */ new Map()
+        presets: /* @__PURE__ */ new Map(),
+        datasources: /* @__PURE__ */ new Map()
       }
     };
     const promises = [
       fetchComponents(space),
       fetchComponentGroups(space),
       fetchComponentPresets(space),
-      fetchComponentInternalTags(space)
+      fetchComponentInternalTags(space),
+      fetchDatasources(space)
     ];
-    const [components, groups, presets, internalTags] = await Promise.all(promises);
+    const [components, groups, presets, internalTags, datasources] = await Promise.all(promises);
     if (components) {
       components.forEach((component) => {
         spaceState.target.components.set(component.name, component);
@@ -2546,6 +2839,11 @@ componentsCommand.command("push [componentName]").description(`Push your space's
         spaceState.target.tags.set(tag.name, tag);
       });
     }
+    if (datasources) {
+      datasources.forEach((datasource) => {
+        spaceState.target.datasources.set(datasource.name, datasource);
+      });
+    }
     if (componentName) {
       spaceState.local = filterSpaceDataByComponent(spaceState.local, componentName);
       if (!spaceState.local.components.length) {
@@ -2617,11 +2915,11 @@ const saveLanguagesToFile = async (space, internationalizationOptions, options)
   }
 };
 
-const program$7 = getProgram();
-const languagesCommand = program$7.command("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$b = getProgram();
+const languagesCommand = program$b.command("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$7.opts().verbose;
+  const verbose = program$b.opts().verbose;
   const { space, path } = languagesCommand.opts();
   const { filename = "languages", suffix = options.space } = options;
   const { state, initializeSession } = session();
@@ -2662,8 +2960,8 @@ languagesCommand.command("pull").description(`Download your space's languages sc
   konsola.br();
 });
 
-const program$6 = getProgram();
-const migrationsCommand = program$6.command("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$a = getProgram();
+const migrationsCommand = program$a.command("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) {
@@ -2691,10 +2989,10 @@ const generateMigration = async (space, path, component, suffix) => {
   }
 };
 
-const program$5 = getProgram();
+const program$9 = getProgram();
 migrationsCommand.command("generate [componentName]").description("Generate a migration file").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. {component-name}.<suffix>.js)").action(async (componentName, options) => {
   konsola.title(` ${commands.MIGRATIONS} `, colorPalette.MIGRATIONS, componentName ? `Generating migration for component ${componentName}...` : "Generating migrations...");
-  const verbose = program$5.opts().verbose;
+  const verbose = program$9.opts().verbose;
   const { space, path } = migrationsCommand.opts();
   const { suffix } = options;
   if (!componentName) {
@@ -3110,10 +3408,10 @@ const isStoryWithUnpublishedChanges = (story) => {
   return story.published && story.unpublished_changes;
 };
 
-const program$4 = getProgram();
+const program$8 = getProgram();
 migrationsCommand.command("run [componentName]").description("Run migrations").option("--fi, --filter <filter>", "glob filter to apply to the components before pushing").option("-d, --dry-run", "Preview changes without applying them to 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/"').option("--publish <publish>", "Options for publication mode: all | published | published-with-changes").action(async (componentName, options) => {
   konsola.title(` ${commands.MIGRATIONS} `, colorPalette.MIGRATIONS, componentName ? `Running migrations for component ${componentName}...` : "Running migrations...");
-  const verbose = program$4.opts().verbose;
+  const verbose = program$8.opts().verbose;
   const { filter, dryRun = false, query, startsWith, publish } = options;
   const { space, path } = migrationsCommand.opts();
   const { state, initializeSession } = session();
@@ -3267,10 +3565,10 @@ migrationsCommand.command("run [componentName]").description("Run migrations").o
   }
 });
 
-const program$3 = getProgram();
+const program$7 = getProgram();
 migrationsCommand.command("rollback [migrationFile]").description("Rollback a migration").action(async (migrationFile) => {
   konsola.title(` ${commands.MIGRATIONS} `, colorPalette.MIGRATIONS, `Rolling back migration ${chalk.hex(colorPalette.MIGRATIONS)(migrationFile)}...`);
-  const verbose = program$3.opts().verbose;
+  const verbose = program$7.opts().verbose;
   const { space, path } = migrationsCommand.opts();
   const { state, initializeSession } = session();
   await initializeSession();
@@ -3309,8 +3607,8 @@ migrationsCommand.command("rollback [migrationFile]").description("Rollback a mi
   }
 });
 
-const program$2 = getProgram();
-const typesCommand = program$2.command("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$6 = getProgram();
+const typesCommand = program$6.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",
@@ -4009,20 +4307,11 @@ const generateStoryblokTypes = async (options = {}) => {
   }
 };
 
-const program$1 = getProgram();
+const program$5 = getProgram();
 typesCommand.command("generate").description("Generate types d.ts for your component schemas").option("--sf, --separate-files", "").option("--strict", "strict mode, no loose typing").option("--type-prefix <prefix>", "prefix to be prepended 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$1.opts().verbose;
+  const verbose = program$5.opts().verbose;
   const { space, path } = typesCommand.opts();
-  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 spinner = new Spinner({
     verbose: !isVitest
   });
@@ -4037,7 +4326,11 @@ typesCommand.command("generate").description("Generate types d.ts for your compo
       ...options,
       path
     });
-    const typedefString = await generateTypes(spaceData, {
+    const spaceDataWithDatasources = {
+      ...spaceData,
+      datasources: []
+    };
+    const typedefString = await generateTypes(spaceDataWithDatasources, {
       ...options,
       path
     });
@@ -4057,7 +4350,529 @@ typesCommand.command("generate").description("Generate types d.ts for your compo
   }
 });
 
-const version = "4.0.5";
+const program$4 = getProgram();
+const datasourcesCommand = program$4.command("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$3 = 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$3.opts().verbose;
+  const { space, path } = datasourcesCommand.opts();
+  const { separateFiles, suffix, filename = "datasources" } = options;
+  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: password,
+    region
+  });
+  const spinnerDatasources = new Spinner({
+    verbose: !isVitest
+  });
+  try {
+    spinnerDatasources.start(`Fetching ${chalk.hex(colorPalette.DATASOURCES)("datasources")}`);
+    let datasources;
+    if (datasourceName) {
+      const datasource = await fetchDatasource(space, datasourceName);
+      if (!datasource) {
+        konsola.warn(`No datasource found with name "${datasourceName}"`);
+        return;
+      }
+      datasources = [datasource];
+    } else {
+      datasources = await fetchDatasources(space);
+      if (!datasources || datasources.length === 0) {
+        konsola.warn(`No datasources found in the space ${space}`);
+        return;
+      }
+    }
+    spinnerDatasources.succeed(`${chalk.hex(colorPalette.DATASOURCES)("Datasources")} - Completed in ${spinnerDatasources.elapsedTime.toFixed(2)}ms`);
+    await saveDatasourcesToFiles(
+      space,
+      datasources,
+      { ...options, path, separateFiles: separateFiles || !!datasourceName }
+    );
+    konsola.br();
+    if (separateFiles) {
+      if (filename !== "datasources") {
+        konsola.warn(`The --filename option is ignored when using --separate-files`);
+      }
+      const filePath = path ? `${path}/datasources/${space}/` : `.storyblok/datasources/${space}/`;
+      konsola.ok(`Datasources downloaded successfully to ${chalk.hex(colorPalette.PRIMARY)(filePath)}`);
+    } else if (datasourceName) {
+      const fileName = suffix ? `${filename}.${suffix}.json` : `${datasourceName}.json`;
+      const filePath = path ? `${path}/datasources/${space}/${fileName}` : `.storyblok/datasources/${space}/${fileName}`;
+      konsola.ok(`Datasource ${chalk.hex(colorPalette.PRIMARY)(datasourceName)} downloaded successfully in ${chalk.hex(colorPalette.PRIMARY)(filePath)}`);
+    } else {
+      const fileName = suffix ? `${filename}.${suffix}.json` : `${filename}.json`;
+      const filePath = path ? `${path}/datasources/${space}/${fileName}` : `.storyblok/datasources/${space}/${fileName}`;
+      konsola.ok(`Datasources downloaded successfully to ${chalk.hex(colorPalette.PRIMARY)(filePath)}`);
+    }
+    konsola.br();
+  } catch (error) {
+    spinnerDatasources.failed(`Fetching ${chalk.hex(colorPalette.DATASOURCES)("Datasources")} - Failed`);
+    konsola.br();
+    handleError(error, verbose);
+  }
+});
+
+const program$2 = 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$2.opts().verbose;
+  const { space, path } = datasourcesCommand.opts();
+  const { from, filter } = options;
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError(`Please provide the target space as argument --space TARGET_SPACE_ID.`), verbose);
+    return;
+  }
+  if (!from) {
+    options.from = space;
+  }
+  konsola.info(`Attempting to push datasources ${chalk.bold("from")} space ${chalk.hex(colorPalette.DATASOURCES)(options.from || space)} ${chalk.bold("to")} ${chalk.hex(colorPalette.DATASOURCES)(space)}`);
+  konsola.br();
+  const { password, region } = state;
+  mapiClient({
+    token: password,
+    region
+  });
+  try {
+    const spaceState = {
+      local: await readDatasourcesFiles({
+        ...options,
+        path,
+        space
+      }),
+      target: {
+        datasources: /* @__PURE__ */ new Map()
+      }
+    };
+    const targetSpaceDatasources = await fetchDatasources(space);
+    if (targetSpaceDatasources) {
+      targetSpaceDatasources.forEach((datasource) => {
+        spaceState.target.datasources.set(datasource.name, datasource);
+      });
+    }
+    if (datasourceName) {
+      spaceState.local = {
+        datasources: [spaceState.local.datasources.find((datasource) => datasource.name === datasourceName) || []]
+      };
+      if (!spaceState.local.datasources.length) {
+        handleError(new CommandError(`Datasource "${datasourceName}" not found.`), verbose);
+        return;
+      }
+    } else if (filter) {
+      spaceState.local.datasources = spaceState.local.datasources.filter((datasource) => datasource.name.includes(filter));
+      if (!spaceState.local.datasources.length) {
+        handleError(new CommandError(`No datasources found matching pattern "${filter}".`), verbose);
+        return;
+      }
+      konsola.info(`Filter applied: ${filter}`);
+    }
+    if (!spaceState.local.datasources.length) {
+      konsola.warn("No datasources found. Please make sure you have pulled the datasources first.");
+      return;
+    }
+    const results = {
+      successful: [],
+      failed: []
+    };
+    for (const datasource of spaceState.local.datasources) {
+      const spinner = new Spinner({
+        verbose: !isVitest
+      });
+      spinner.start(`Pushing ${chalk.hex(colorPalette.DATASOURCES)(datasource.name)}`);
+      const existingDatasource = spaceState.target.datasources.get(datasource.name);
+      const existingId = existingDatasource?.id;
+      const { entries, ...datasourceDefinition } = datasource;
+      const result = await upsertDatasource(space, datasourceDefinition, existingId);
+      if (result) {
+        results.successful.push(datasource.name);
+        if (entries && entries.length > 0) {
+          for (const entry of entries) {
+            const existingEntryId = existingDatasource?.entries?.find((e) => e.name === entry.name)?.id;
+            try {
+              const { id, ...entryData } = entry;
+              await upsertDatasourceEntry(space, result.id, entryData, existingEntryId);
+            } catch (entryError) {
+              results.failed.push({ name: datasource.name, error: entryError });
+              spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
+            }
+          }
+        }
+        spinner.succeed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Completed in ${spinner.elapsedTime.toFixed(2)}ms`);
+      } else {
+        results.failed.push({ name: datasource.name, error: result });
+        spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
+      }
+    }
+    if (results.failed.length > 0) {
+      if (!verbose) {
+        konsola.br();
+        konsola.info("For more information about the error, run the command with the `--verbose` flag");
+      } else {
+        results.failed.forEach((failed) => {
+          handleError(failed.error, verbose);
+        });
+      }
+    }
+  } catch (error) {
+    handleError(error, verbose);
+  }
+});
+
+async function deleteDatasource(space, id) {
+  try {
+    const client = mapiClient();
+    await client.delete(`spaces/${space}/datasources/${id}`);
+  } catch (error) {
+    handleAPIError("delete_datasource", error, `Datasource with id '${id}' not found in space ${space}.`);
+  }
+}
+
+datasourcesCommand.command("delete [name]").description("Delete a datasource from your space by name or id").option("--id <id>", "Delete by datasource id instead of name").option("--force", "Skip confirmation prompt for deletion (useful for CI)").action(async (name, options) => {
+  konsola.title(
+    ` ${commands.DATASOURCES} `,
+    colorPalette.DATASOURCES,
+    options.id ? `Deleting datasource with id ${options.id}...` : `Deleting datasource with name ${name}...`
+  );
+  if (name && options.id) {
+    konsola.warn(
+      "Both a datasource name and an id were provided. Only one is required. The id will be used as the source of truth."
+    );
+  }
+  const { space } = datasourcesCommand.opts();
+  const verbose = datasourcesCommand.parent?.opts().verbose;
+  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: password,
+    region
+  });
+  const spinner = new Spinner({
+    verbose: !isVitest
+  });
+  try {
+    if (options.id) {
+      spinner.start(`Deleting datasource...`);
+      await deleteDatasource(space, options.id);
+      spinner.succeed();
+      konsola.ok(`Datasource ${chalk.hex(colorPalette.DATASOURCES)(options.id)} deleted successfully from space ${space}.`);
+    } else {
+      const datasource = await fetchDatasource(space, name);
+      if (!datasource) {
+        throw new CommandError(`Datasource with name '${name}' not found in space ${space}.`);
+      }
+      if (!options.force) {
+        konsola.info(`Datasource details:`);
+        console.log(`  Name: ${chalk.hex(colorPalette.DATASOURCES)(datasource.name)}`);
+        console.log(`  ID: ${chalk.hex(colorPalette.DATASOURCES)(datasource.id)}`);
+        console.log(`  Space: ${chalk.hex(colorPalette.DATASOURCES)(space)}`);
+        console.log(`  Slug: ${chalk.hex(colorPalette.DATASOURCES)(datasource.slug)}`);
+        console.log(`  Created at: ${chalk.hex(colorPalette.DATASOURCES)(datasource.created_at)}`);
+        console.log(`  Updated at: ${chalk.hex(colorPalette.DATASOURCES)(datasource.updated_at)}`);
+        konsola.br();
+        const confirmed = await confirm({
+          message: `\u26A0\uFE0F ${chalk.yellow(` Are you sure you want to delete the ${datasource.name} datasource from space ${space}? This action cannot be undone.`)} `,
+          default: false
+        });
+        if (!confirmed) {
+          spinner.failed("Deletion aborted by user.");
+          konsola.warn("Deletion aborted by user.");
+          return;
+        }
+      }
+      spinner.start(`Deleting datasource...`);
+      await deleteDatasource(space, datasource.id.toString());
+      spinner.succeed();
+      konsola.ok(`Datasource ${chalk.hex(colorPalette.DATASOURCES)(name)} deleted successfully from space ${space}.`);
+    }
+  } catch (error) {
+    spinner.failed(
+      `Failed to delete datasource ${chalk.hex(colorPalette.DATASOURCES)(options.id ? options.id : name)}`
+    );
+    handleError(error, verbose);
+  }
+});
+
+let octokit;
+let lastToken;
+const createOctokit = (token) => {
+  if (!octokit || token !== lastToken) {
+    const options = {
+      request: {
+        fetch
+      }
+    };
+    octokit = new Octokit(options);
+  }
+  return octokit;
+};
+
+const generateProject = async (blueprint, projectName, targetPath = process.cwd()) => {
+  try {
+    const projectPath = path.join(targetPath, projectName);
+    const templateRepo = `storyblok/blueprint-core-${blueprint}`;
+    try {
+      await fs.access(projectPath);
+      const existsError = new Error(`Directory ${projectName} already exists`);
+      existsError.code = "ENOTEMPTY";
+      existsError.path = projectPath;
+      throw new FileSystemError("directory_not_empty", "mkdir", existsError, `Directory ${projectName} already exists`);
+    } catch (error) {
+      const fsError = error;
+      if (fsError.code === "ENOENT") {
+      } else {
+        handleFileSystemError("read", fsError);
+      }
+    }
+    const degitProcess = spawn("npx", ["degit", templateRepo, projectPath], {
+      stdio: "inherit",
+      shell: true
+    });
+    return new Promise((resolve, reject) => {
+      degitProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Failed to clone template. Process exited with code ${code}`));
+        }
+      });
+      degitProcess.on("error", (error) => {
+        reject(new Error(`Failed to spawn degit process: ${error.message}`));
+      });
+    });
+  } catch (error) {
+    handleFileSystemError("read", error);
+  }
+};
+const createEnvFile = async (projectPath, accessToken, additionalVars) => {
+  try {
+    const envPath = path.join(projectPath, ".env");
+    let envContent = `# Storyblok Configuration
+STORYBLOK_DELIVERY_API_TOKEN=${accessToken}
+`;
+    if (additionalVars && Object.keys(additionalVars).length > 0) ;
+    await saveToFile(envPath, envContent);
+  } catch (error) {
+    throw new Error(`Failed to create .env file: ${error.message}`);
+  }
+};
+const generateSpaceUrl = (spaceId, region) => {
+  const domain = appDomains[region];
+  return `https://${domain}/#/me/spaces/${spaceId}/dashboard`;
+};
+const openSpaceInBrowser = async (spaceId, region) => {
+  try {
+    const spaceUrl = generateSpaceUrl(spaceId, region);
+    await open(spaceUrl);
+  } catch (error) {
+    throw new Error(`Failed to open space in browser: ${error.message}`);
+  }
+};
+const extractPortFromTopics = (topics) => {
+  const portTopic = topics.find((topic) => topic.startsWith("port-"));
+  if (portTopic) {
+    const port = portTopic.replace("port-", "");
+    if (/^\d+$/.test(port) && Number.parseInt(port) > 0 && Number.parseInt(port) <= 65535) {
+      return port;
+    }
+  }
+  return "3000";
+};
+const repositoryToBlueprint = (repo) => {
+  const technology = repo.name.replace("blueprint-core-", "");
+  const port = extractPortFromTopics(repo.topics || []);
+  return {
+    name: technology.charAt(0).toUpperCase() + technology.slice(1),
+    value: technology,
+    template: repo.clone_url,
+    location: port ? `https://localhost:${port}/` : "https://localhost:3000/",
+    description: repo.description,
+    updated_at: repo.updated_at
+  };
+};
+const fetchBlueprintRepositories = async () => {
+  try {
+    const octokit = createOctokit();
+    const { data } = await octokit.rest.search.repos({
+      q: "org:storyblok blueprint-core-",
+      sort: "updated",
+      order: "desc",
+      per_page: 100
+    });
+    const blueprints = data.items.filter((repo) => repo.name.startsWith("blueprint-core-")).map(repositoryToBlueprint).sort((a, b) => a.name.localeCompare(b.name));
+    return blueprints;
+  } catch (error) {
+    handleAPIError("fetch_blueprints", error, "Failed to fetch blueprints from GitHub");
+  }
+};
+
+const createSpace = async (space) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.post("spaces", {
+      body: JSON.stringify(space)
+    });
+    return data.space;
+  } catch (error) {
+    handleAPIError("create_space", error, `Failed to create space ${space.name}`);
+  }
+};
+
+const program$1 = getProgram();
+program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-b, --blueprint <blueprint>", "technology starter blueprint").option("--skip-space", "skip space creation").action(async (projectPath, options) => {
+  konsola.title(` ${commands.CREATE} `, colorPalette.CREATE);
+  const verbose = program$1.opts().verbose;
+  const { blueprint } = options;
+  const { state, initializeSession } = session();
+  await initializeSession();
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  const { password, region } = state;
+  mapiClient({
+    token: password,
+    region
+  });
+  const spinnerBlueprints = new Spinner({
+    verbose: !isVitest
+  });
+  const spinnerSpace = new Spinner({
+    verbose: !isVitest
+  });
+  try {
+    spinnerBlueprints.start("Fetching starter blueprints...");
+    const blueprints = await fetchBlueprintRepositories();
+    spinnerBlueprints.succeed("Starter blueprints fetched successfully");
+    if (!blueprints) {
+      spinnerBlueprints.failed();
+      konsola.warn("No starter blueprints found. Please contact support@storyblok.com");
+      konsola.br();
+      return;
+    }
+    let technologyBlueprint = blueprint;
+    if (blueprint) {
+      const validBlueprints = blueprints;
+      const isValidBlueprint = validBlueprints.find((bp) => bp.value === blueprint);
+      if (!isValidBlueprint) {
+        const validOptions = validBlueprints.map((bp) => bp.value).join(", ");
+        konsola.warn(`Invalid blueprint "${chalk.hex(colorPalette.CREATE)(blueprint)}". Valid options are: ${chalk.hex(colorPalette.CREATE)(validOptions)}`);
+        konsola.br();
+        technologyBlueprint = void 0;
+      }
+    }
+    if (!technologyBlueprint) {
+      technologyBlueprint = await select({
+        message: "Please select the technology you would like to use:",
+        choices: blueprints.map((blueprint2) => ({
+          name: blueprint2.name,
+          value: blueprint2.value
+        }))
+      });
+    }
+    let finalProjectPath = projectPath;
+    if (!projectPath) {
+      finalProjectPath = await input({
+        message: "What is the path for your project?",
+        default: `./my-${technologyBlueprint}-project`,
+        validate: (value) => {
+          if (!value.trim()) {
+            return "Project path is required";
+          }
+          const projectName2 = path.basename(value);
+          if (!/^[\w-]+$/.test(projectName2)) {
+            return "Project name (last part of the path) can only contain letters, numbers, hyphens, and underscores";
+          }
+          return true;
+        }
+      });
+    }
+    const resolvedPath = path.resolve(finalProjectPath);
+    const targetDirectory = path.dirname(resolvedPath);
+    const projectName = path.basename(resolvedPath);
+    konsola.br();
+    konsola.info(`Scaffolding your project using the ${chalk.hex(colorPalette.CREATE)(technologyBlueprint)} blueprint...`);
+    await generateProject(technologyBlueprint, projectName, targetDirectory);
+    konsola.ok(`Project ${chalk.hex(colorPalette.PRIMARY)(projectName)} created successfully in ${chalk.hex(colorPalette.PRIMARY)(finalProjectPath)}`, true);
+    let createdSpace;
+    if (!options.skipSpace) {
+      try {
+        spinnerSpace.start(`Creating space "${toHumanReadable(projectName)}"`);
+        const selectedBlueprint = blueprints.find((bp) => bp.value === technologyBlueprint);
+        const blueprintDomain = selectedBlueprint?.location || "https://localhost:3000/";
+        createdSpace = await createSpace({
+          name: toHumanReadable(projectName),
+          domain: blueprintDomain
+        });
+        spinnerSpace.succeed(`Space "${chalk.hex(colorPalette.PRIMARY)(toHumanReadable(projectName))}" created successfully`);
+      } catch (error) {
+        spinnerSpace.failed();
+        konsola.br();
+        handleError(error, verbose);
+        return;
+      }
+    }
+    if (createdSpace?.first_token) {
+      try {
+        await createEnvFile(resolvedPath, createdSpace.first_token);
+        konsola.ok(`Created .env file with Storyblok access token`, true);
+      } catch (error) {
+        konsola.warn(`Failed to create .env file: ${error.message}`);
+        konsola.info(`You can manually add this token to your .env file: ${createdSpace.first_token}`);
+      }
+    }
+    if (createdSpace?.id) {
+      try {
+        await openSpaceInBrowser(createdSpace.id, region);
+        konsola.info(`Opened space in your browser`);
+      } catch (error) {
+        konsola.warn(`Failed to open browser: ${error.message}`);
+        const spaceUrl = generateSpaceUrl(createdSpace.id, region);
+        konsola.info(`You can manually open your space at: ${chalk.hex(colorPalette.PRIMARY)(spaceUrl)}`);
+      }
+    }
+    konsola.br();
+    konsola.ok(`Your ${chalk.hex(colorPalette.PRIMARY)(technologyBlueprint)} project is ready \u{1F389} !`);
+    if (createdSpace?.first_token) {
+      konsola.ok(`Storyblok space created, preview url and .env configured automatically`);
+    }
+    konsola.br();
+    konsola.info(`Next steps:
+  cd ${finalProjectPath}
+  npm install
+  npm run dev
+`);
+  } catch (error) {
+    spinnerSpace.failed();
+    spinnerBlueprints.failed();
+    konsola.br();
+    handleError(error, verbose);
+  }
+  konsola.br();
+});
+
+const version = "4.2.0";
 const pkg = {
 	version: version};