@akanjs/cli 2.4.0-rc.9 → 2.4.1-rc.0

package/index-r24hmh0q.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/index-ss469dec.js

@@ -0,0 +1,11 @@
+// @bun
+// pkgs/@akanjs/cli/pluralizeName.ts
+function pluralizeName(name) {
+  if (/[^aeiou]y$/i.test(name))
+    return `${name.slice(0, -1)}ies`;
+  if (/(s|x|z|ch|sh)$/i.test(name))
+    return `${name}es`;
+  return `${name}s`;
+}
+
+export { pluralizeName };

package/index-swf4bmbg.js

@@ -0,0 +1,25 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-hdqztm58.js";
+
+// pkgs/@akanjs/cli/page/page.runner.ts
+class PageRunner extends runner("page") {
+  async createCrudPage(module, { app, basePath, single = false }) {
+    await app.applyTemplate({
+      basePath: basePath ?? `page/(${app.name})/(public)/${module.name}`,
+      template: single ? "crudSinglePage" : "crudPages",
+      dict: { model: module.name, appName: module.sys.name }
+    });
+  }
+}
+
+// pkgs/@akanjs/cli/page/page.script.ts
+class PageScript extends script("page", [PageRunner]) {
+  async createCrudPage(module, { app, basePath, single = false }) {
+    await this.pageRunner.createCrudPage(module, { app, basePath, single });
+  }
+}
+
+export { PageScript };

package/index-w7fyqjrw.js

@@ -0,0 +1,462 @@
+// @bun
+import {
+  openBrowser
+} from "./index-9sp6fsc5.js";
+import {
+  AiSession,
+  CloudApi,
+  GlobalConfig,
+  getDefaultHostConfig
+} from "./index-5vvwc0cz.js";
+import {
+  runner
+} from "./index-hdqztm58.js";
+import {
+  AppExecutor,
+  WorkspaceExecutor
+} from "./index-a6sbyy0b.js";
+
+// pkgs/@akanjs/cli/cloud/cloud.runner.ts
+import path from "path";
+import { confirm, input, select } from "@inquirer/prompts";
+import { Logger, sleep } from "akanjs/common";
+import chalk from "chalk";
+import * as QRcode from "qrcode";
+
+// pkgs/@akanjs/cli/npmRegistry.ts
+var defaultNpmRegistry = "https://registry.npmjs.org";
+var getNpmRegistryUrl = (registryUrl = process.env.AKAN_NPM_REGISTRY ?? defaultNpmRegistry) => registryUrl.replace(/\/+$/, "");
+async function getLatestPackageVersion(packageName, tag = "latest", registryUrl) {
+  const registry = getNpmRegistryUrl(registryUrl);
+  const url = `${registry}/${encodeURIComponent(packageName).replace(/^%40/, "@")}`;
+  const res = await fetch(url);
+  if (!res.ok)
+    throw new Error(`Failed to fetch ${packageName} metadata from ${registry}`);
+  const metadata = await res.json();
+  const version = metadata["dist-tags"]?.[tag];
+  if (!version)
+    throw new Error(`No npm dist-tag "${tag}" found for ${packageName}`);
+  return version;
+}
+
+// pkgs/@akanjs/cli/cloud/cloud.runner.ts
+var addRemoteEnvServerValue = "__addRemoteEnvServer";
+var removeRemoteEnvServerValue = "__removeRemoteEnvServer";
+
+class CloudRunner extends runner("cloud") {
+  #akanFrameworkPackages = new Set(["akanjs", "@akanjs/devkit", "@akanjs/cli", "create-akan-workspace"]);
+  #getRegistryArgs(registryUrl) {
+    return registryUrl ? ["--registry", getNpmRegistryUrl(registryUrl)] : [];
+  }
+  #getLocalRegistryAuthArgs(registryUrl) {
+    if (!registryUrl)
+      return [];
+    const { host, pathname } = new URL(getNpmRegistryUrl(registryUrl));
+    const registryPath = pathname === "/" ? "/" : `${pathname.replace(/\/+$/, "")}/`;
+    return [`--//${host}${registryPath}:_authToken=akan-local-registry`];
+  }
+  #getRegistryEnv(registryUrl) {
+    return registryUrl ? {
+      ...process.env,
+      AKAN_NPM_REGISTRY: getNpmRegistryUrl(registryUrl),
+      NPM_CONFIG_REGISTRY: getNpmRegistryUrl(registryUrl)
+    } : process.env;
+  }
+  async#addRemoteEnvServer() {
+    const name = (await input({
+      message: "Remote server name: ",
+      validate: (value) => value.trim() ? true : "Remote server name is required"
+    })).trim();
+    const host = (await input({
+      message: "Remote server host: ",
+      validate: (value) => value.trim() ? true : "Remote server host is required"
+    })).trim();
+    const username = (await input({ message: "Remote server username (optional): " })).trim() || undefined;
+    const portInput = (await input({
+      message: "Remote server SSH port (optional): ",
+      validate: (value) => {
+        const trimmed = value.trim();
+        if (!trimmed)
+          return true;
+        const port = Number(trimmed);
+        return Number.isInteger(port) && port > 0 ? true : "SSH port must be a positive integer";
+      }
+    })).trim();
+    const config = {
+      host,
+      ...username ? { username } : {},
+      ...portInput ? { port: Number(portInput) } : {}
+    };
+    await GlobalConfig.setRemoteEnvServer(name, config);
+    return { name, config };
+  }
+  async#selectRemoteEnvServer() {
+    const servers = await GlobalConfig.getRemoteEnvServers();
+    const serverEntries = Object.entries(servers).sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
+    if (serverEntries.length === 0) {
+      Logger.info("No remote env servers configured. Add the first remote server for SCP mode.");
+      return await this.#addRemoteEnvServer();
+    }
+    const selectedName = await select({
+      message: "Select the remote env server",
+      choices: [
+        ...serverEntries.map(([name, config2]) => ({
+          name: `${name} (${config2.username ? `${config2.username}@` : ""}${config2.host}${config2.port ? `:${config2.port}` : ""})`,
+          value: name
+        })),
+        { name: "Add new remote server", value: addRemoteEnvServerValue },
+        { name: "Remove remote server", value: removeRemoteEnvServerValue }
+      ]
+    });
+    if (selectedName === addRemoteEnvServerValue)
+      return await this.#addRemoteEnvServer();
+    if (selectedName === removeRemoteEnvServerValue) {
+      await this.#removeRemoteEnvServer(serverEntries);
+      return await this.#selectRemoteEnvServer();
+    }
+    const config = servers[selectedName];
+    if (!config)
+      throw new Error(`Remote env server is not found: ${selectedName}`);
+    return { name: selectedName, config };
+  }
+  async#removeRemoteEnvServer(serverEntries) {
+    const selectedName = await select({
+      message: "Select the remote env server to remove",
+      choices: serverEntries.map(([name, config]) => ({
+        name: `${name} (${config.username ? `${config.username}@` : ""}${config.host}${config.port ? `:${config.port}` : ""})`,
+        value: name
+      }))
+    });
+    const shouldRemove = await confirm({
+      message: `Remove remote env server "${selectedName}"?`,
+      default: false
+    });
+    if (!shouldRemove)
+      return;
+    await GlobalConfig.removeRemoteEnvServer(selectedName);
+    Logger.info(`Removed remote env server "${selectedName}"`);
+  }
+  async#getRemoteEnvServerWithUsername() {
+    const remoteServer = await this.#selectRemoteEnvServer();
+    if (remoteServer.config.username)
+      return remoteServer;
+    const username = (await input({
+      message: `SSH username for ${remoteServer.config.host} (optional): `
+    })).trim();
+    return {
+      ...remoteServer,
+      config: {
+        ...remoteServer.config,
+        ...username ? { username } : {}
+      }
+    };
+  }
+  #getRemoteEnvArchivePath() {
+    return `${this.#getRemoteEnvArchiveDir()}/env.tar`;
+  }
+  #getRemoteEnvArchiveDir() {
+    const { repoName } = WorkspaceExecutor.getBaseDevEnv();
+    return `~/secrets/${repoName}`;
+  }
+  #getScpTarget(config, remotePath) {
+    return `${config.username ? `${config.username}@` : ""}${config.host}:${remotePath}`;
+  }
+  #getSshTarget(config) {
+    return `${config.username ? `${config.username}@` : ""}${config.host}`;
+  }
+  #getScpArgs(config, source, target) {
+    return [...config.port ? ["-P", config.port.toString()] : [], source, target];
+  }
+  #getSshArgs(config, command) {
+    return [...config.port ? ["-p", config.port.toString()] : [], this.#getSshTarget(config), command];
+  }
+  async login(host, workspace) {
+    const config = await GlobalConfig.getHostConfig(host);
+    const cloudApi = new CloudApi(workspace, config);
+    const self = config.auth ? await cloudApi.getRemoteSelf() : null;
+    if (self) {
+      Logger.rawLog(chalk.green(`
+\u2713 Already logged in akan cloud as ${self.nickname}
+`));
+      return true;
+    }
+    const remoteId = crypto.randomUUID();
+    const signinUrl = `${cloudApi.host}/remoteAuth?remoteId=${encodeURIComponent(remoteId)}`;
+    Logger.rawLog(chalk.bold(`
+${chalk.green("\u27A4")} Authentication Required`));
+    Logger.rawLog(chalk.dim("Please visit or click the following URL:"));
+    Logger.rawLog(`${chalk.cyan.underline(signinUrl)}
+`);
+    try {
+      const qrcode = await new Promise((resolve, reject) => {
+        QRcode.toString(signinUrl, { type: "terminal", small: true }, (err, data) => {
+          if (err)
+            reject(err);
+          resolve(data);
+        });
+      });
+      Logger.rawLog(qrcode);
+      await openBrowser(signinUrl);
+      Logger.rawLog(chalk.dim("Opening browser..."));
+    } catch {
+      Logger.rawLog(chalk.yellow("Could not open browser. Please visit the URL manually."));
+    }
+    Logger.rawLog(chalk.dim("Waiting for authentication..."));
+    const MAX_RETRY = 300;
+    for (let i = 0;i < MAX_RETRY; i++) {
+      const accessToken = await cloudApi.getRemoteAuthToken(remoteId);
+      const self2 = await cloudApi.getRemoteSelf();
+      if (accessToken && self2) {
+        await GlobalConfig.setHostConfig({ host: config.host, auth: { accessToken, self: self2 } });
+        Logger.rawLog(chalk.green(`\r\u2713 Authentication successful!`));
+        Logger.rawLog(chalk.green.bold(`
+\u2728 Welcome aboard, ${self2.nickname ?? "anonymous"}!`));
+        Logger.rawLog(chalk.dim(`You're now ready to use Akan CLI!
+`));
+        return true;
+      }
+      await sleep(2000);
+    }
+    throw new Error(chalk.red("\u2716 Authentication timed out after 10 minutes. Please try again."));
+  }
+  async logout(host) {
+    const config = await GlobalConfig.getHostConfig(host);
+    if (config.auth?.self) {
+      await GlobalConfig.setHostConfig(getDefaultHostConfig(config.host));
+      Logger.rawLog(chalk.magenta.bold(`
+\uD83D\uDC4B Goodbye, ${config.auth.self.nickname ?? "anonymous"}!`));
+      Logger.rawLog(chalk.dim(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`));
+      Logger.rawLog(chalk.cyan("You have been successfully logged out."));
+      Logger.rawLog(chalk.dim(`Thank you for using Akan CLI. Come back soon! \uD83C\uDF1F
+`));
+    } else {
+      Logger.rawLog(chalk.yellow.bold(`
+\u26A0\uFE0F  No active session found`));
+      Logger.rawLog(chalk.dim(`You were not logged in to begin with
+`));
+    }
+  }
+  async setLlm() {
+    await AiSession.init({ useExisting: false });
+  }
+  resetLlm() {
+    AiSession.setLlmConfig(null);
+    Logger.rawLog(chalk.green("\u2611\uFE0F LLM model config is cleared. Please run `akan set-llm` to set a new LLM model."));
+  }
+  async getAkanPkgs(workspace) {
+    const pkgs = await workspace.getPkgs();
+    return pkgs.filter((pkg) => pkg === "akanjs" || pkg === "create-akan-workspace" || pkg.startsWith("@akanjs/"));
+  }
+  async deployAkan(workspace, akanPkgs, { registryUrl, confirmPublish = true, tag: distTag } = {}) {
+    const registry = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
+    const akanPackageJson = await workspace.readJson("pkgs/akanjs/package.json");
+    const [majorVersion, minorVersion, patchVersion, devPatchVersion] = akanPackageJson.version.split(".");
+    const isOfficialRelease = !devPatchVersion;
+    const targetVersionPrefix = isOfficialRelease ? `${majorVersion}.${minorVersion}` : `${majorVersion}.${minorVersion}.${patchVersion}`;
+    const tag = distTag ?? (isOfficialRelease ? "latest" : patchVersion.split("-").at(1) ?? "dev");
+    const getNextVersion = async (prefix, tag2) => {
+      try {
+        const latestPublishedVersion2 = await getLatestPackageVersion("akanjs", tag2, registry);
+        const latestPatch = latestPublishedVersion2.startsWith(prefix) ? parseInt(latestPublishedVersion2.split(".").at(-1) ?? "-1") : -1;
+        const nextVersion2 = `${prefix}.${latestPatch + 1}`;
+        return { nextVersion: nextVersion2, latestPublishedVersion: latestPublishedVersion2 };
+      } catch {
+        return { nextVersion: `${prefix}.0`, latestPublishedVersion: null };
+      }
+    };
+    const { nextVersion, latestPublishedVersion } = await getNextVersion(targetVersionPrefix, tag);
+    Logger.info(`Latest published version of akanjs: ${latestPublishedVersion ?? "none"}`);
+    Logger.info(`Next version of akanjs: ${nextVersion}`);
+    for (const library of akanPkgs) {
+      const packageJson = await workspace.readJson(`pkgs/${library}/package.json`);
+      const newPackageJsonStr = JSON.stringify(this.#normalizeAkanPackageJson(packageJson, library, nextVersion), null, 2);
+      await workspace.writeFile(`pkgs/${library}/package.json`, newPackageJsonStr);
+      const distPackageJson = await workspace.readJson(`dist/pkgs/${library}/package.json`);
+      const newDistPackageJson = this.#normalizeAkanPackageJson(distPackageJson, library, nextVersion);
+      await workspace.writeJson(`dist/pkgs/${library}/package.json`, newDistPackageJson);
+    }
+    if (confirmPublish) {
+      const isDeployConfirmed = await confirm({
+        message: "Are you sure you want to deploy the libraries?"
+      });
+      if (!isDeployConfirmed) {
+        Logger.error("Deployment cancelled");
+        return;
+      }
+    }
+    await Promise.all(akanPkgs.map(async (library) => {
+      Logger.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
+      await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
+        cwd: path.join(workspace.workspaceRoot, "dist/pkgs", library),
+        env: this.#getRegistryEnv(registry),
+        stdio: "inherit"
+      });
+      Logger.info(`${library}@${nextVersion} is published to ${registry ?? "npm"}`);
+    }));
+    Logger.info(`All libraries are published to ${registry ?? "npm"}`);
+  }
+  async update(workspace, tag = "latest", { registryUrl } = {}) {
+    const registry = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
+    const registryArgs = this.#getRegistryArgs(registry);
+    const env = this.#getRegistryEnv(registry);
+    if (!await workspace.exists("package.json"))
+      await workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`, ...registryArgs], { env });
+    else
+      await Promise.all([
+        workspace.spawn("bun", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`, ...registryArgs], { env }),
+        this.#updateAkanPkgs(workspace, tag, registry)
+      ]);
+  }
+  async#updateAkanPkgs(workspace, tag = "latest", registryUrl) {
+    const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag, registryUrl);
+    const rootPackageJson = await workspace.getPackageJson();
+    if (!rootPackageJson.dependencies)
+      throw new Error("No dependencies found in package.json");
+    if (rootPackageJson.dependencies.akanjs)
+      rootPackageJson.dependencies.akanjs = latestPublishedVersion;
+    if (rootPackageJson.devDependencies?.akanjs)
+      rootPackageJson.devDependencies.akanjs = latestPublishedVersion;
+    if (rootPackageJson.dependencies["@akanjs/devkit"])
+      rootPackageJson.dependencies["@akanjs/devkit"] = latestPublishedVersion;
+    if (rootPackageJson.devDependencies?.["@akanjs/devkit"])
+      rootPackageJson.devDependencies["@akanjs/devkit"] = latestPublishedVersion;
+    await workspace.setPackageJson(rootPackageJson);
+    await workspace.spawn("bun", ["install", ...this.#getRegistryArgs(registryUrl)], {
+      env: this.#getRegistryEnv(registryUrl)
+    });
+  }
+  #normalizeAkanPackageJson(packageJson, packageName, version) {
+    const normalized = { ...packageJson, version };
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const dependencies = normalized[field];
+      if (!dependencies)
+        continue;
+      normalized[field] = Object.fromEntries(Object.entries(dependencies).map(([dep, depVersion]) => [
+        dep,
+        dep !== packageName && this.#akanFrameworkPackages.has(dep) ? version : depVersion
+      ]));
+    }
+    return normalized;
+  }
+  async downloadEnv(cloudApi, workspace, workspaceId) {
+    await workspace.mkdir("local");
+    const localPath = await cloudApi.downloadEnv(workspaceId);
+    const relativePath = path.relative(workspace.workspaceRoot, localPath).split(path.sep).join("/");
+    await workspace.spawn("tar", ["-xf", relativePath], { cwd: workspace.workspaceRoot });
+    await workspace.remove(localPath);
+  }
+  async uploadEnv(cloudApi, workspaceId, filePath) {
+    const file = new File([Bun.file(filePath)], path.basename(filePath));
+    await cloudApi.uploadEnv(workspaceId, file);
+  }
+  async downloadEnvByScp(workspace) {
+    const envArchivePath = "local/env.tar";
+    const remoteServer = await this.#getRemoteEnvServerWithUsername();
+    const remoteArchivePath = this.#getRemoteEnvArchivePath();
+    const remoteTarget = this.#getScpTarget(remoteServer.config, remoteArchivePath);
+    await workspace.mkdir("local");
+    await workspace.remove(envArchivePath);
+    try {
+      Logger.info(`Downloading env archive from remote server "${remoteServer.name}"...`);
+      await workspace.spawn("scp", this.#getScpArgs(remoteServer.config, remoteTarget, envArchivePath), {
+        cwd: workspace.workspaceRoot,
+        stdio: "inherit"
+      });
+      await workspace.spawn("tar", ["-xf", envArchivePath], {
+        cwd: workspace.workspaceRoot
+      });
+      await workspace.remove(envArchivePath);
+    } catch (error) {
+      throw new Error(`Failed to download env archive from remote server "${remoteServer.name}"`, { cause: error });
+    }
+  }
+  async uploadEnvByScp(workspace, filePath) {
+    const remoteServer = await this.#getRemoteEnvServerWithUsername();
+    const remoteArchiveDir = this.#getRemoteEnvArchiveDir();
+    const remoteArchivePath = this.#getRemoteEnvArchivePath();
+    const remoteTarget = this.#getScpTarget(remoteServer.config, remoteArchivePath);
+    try {
+      await workspace.spawn("ssh", this.#getSshArgs(remoteServer.config, `mkdir -p ${remoteArchiveDir}`), {
+        cwd: workspace.workspaceRoot,
+        stdio: "inherit"
+      });
+      Logger.info(`Uploading env archive to remote server "${remoteServer.name}"...`);
+      await workspace.spawn("scp", this.#getScpArgs(remoteServer.config, filePath, remoteTarget), {
+        cwd: workspace.workspaceRoot,
+        stdio: "inherit"
+      });
+    } catch (error) {
+      throw new Error(`Failed to upload env archive to remote server "${remoteServer.name}"`, { cause: error });
+    }
+  }
+  async gatherEnvFiles(workspace) {
+    const envFilePattern = /^env\.(client|server)\.(?!(type|example)\.ts$).+\.ts$/;
+    const [appNames, libNames] = await workspace.getExecs();
+    const envDirs = [
+      ...appNames.map((appName) => `apps/${appName}/env`),
+      ...libNames.map((libName) => `libs/${libName}/env`)
+    ];
+    const defaultEnvFilePaths = (await Promise.all(envDirs.map(async (envDir) => (await workspace.readdir(envDir)).filter((fileName) => envFilePattern.test(fileName)).map((fileName) => `${envDir}/${fileName}`)))).flat();
+    await this.#syncSecretGitignore(workspace, appNames);
+    const customSecretPaths = await this.#gatherCustomSecretFiles(workspace, appNames);
+    const envFilePaths = [...new Set([...defaultEnvFilePaths, ...customSecretPaths])].sort();
+    await workspace.mkdir("local");
+    await workspace.remove("local/env.tar");
+    if (envFilePaths.length === 0)
+      throw new Error("No environment files found to archive");
+    await workspace.spawn("tar", ["-cf", "local/env.tar", ...envFilePaths], {
+      cwd: workspace.workspaceRoot
+    });
+    Logger.info(`Archived ${envFilePaths.length} environment files to local/env.tar`);
+    return { files: envFilePaths, path: "local/env.tar" };
+  }
+  async#gatherCustomSecretFiles(workspace, appNames) {
+    const secretPaths = await Promise.all(appNames.map(async (appName) => {
+      const config = await AppExecutor.from(workspace, appName).getConfig();
+      const secretGlobs = config.secrets ?? [];
+      if (secretGlobs.length === 0)
+        return [];
+      const appDir = path.join(workspace.workspaceRoot, "apps", appName);
+      return secretGlobs.flatMap((pattern) => Array.from(new Bun.Glob(pattern).scanSync({ cwd: appDir, onlyFiles: true })).map((match) => `apps/${appName}/${match.split(path.sep).join("/")}`));
+    }));
+    return secretPaths.flat();
+  }
+  async#syncSecretGitignore(workspace, appNames) {
+    const patterns = (await Promise.all(appNames.map(async (appName) => {
+      const config = await AppExecutor.from(workspace, appName).getConfig();
+      return (config.secrets ?? []).map((pattern) => `apps/${appName}/${pattern.replace(/^\/+/, "")}`);
+    }))).flat();
+    const uniquePatterns = [...new Set(patterns)].sort();
+    const existing = await workspace.exists(".gitignore") ? await workspace.readFile(".gitignore") : "";
+    const nextContent = this.#applySecretGitignoreBlock(existing, uniquePatterns);
+    if (nextContent === existing)
+      return;
+    await workspace.writeFile(".gitignore", nextContent);
+    Logger.info(uniquePatterns.length ? `Synced ${uniquePatterns.length} secret pattern(s) from akan.config.ts to .gitignore` : "Removed managed secret patterns from .gitignore");
+  }
+  #applySecretGitignoreBlock(content, patterns) {
+    const beginMarker = "# akan:secrets (managed by akan.config.ts \u2014 do not edit)";
+    const endMarker = "# akan:secrets:end";
+    const lines = content.split(`
+`);
+    const beginIdx = lines.indexOf(beginMarker);
+    const endIdx = lines.indexOf(endMarker);
+    const stripped = beginIdx !== -1 && endIdx !== -1 && endIdx >= beginIdx ? [...lines.slice(0, beginIdx), ...lines.slice(endIdx + 1)] : [...lines];
+    while (stripped.length && stripped[stripped.length - 1]?.trim() === "")
+      stripped.pop();
+    if (patterns.length === 0)
+      return stripped.length ? `${stripped.join(`
+`)}
+` : "";
+    const body = stripped.length ? `${stripped.join(`
+`)}
+
+` : "";
+    return `${body}${[beginMarker, ...patterns, endMarker].join(`
+`)}
+`;
+  }
+}
+
+export { getNpmRegistryUrl, getLatestPackageVersion, CloudRunner };