@cimplify/cli 0.15.3 → 0.17.0

package/dist/{chunk-2MKZKUVH.mjs → chunk-LLRUOIMU.mjs}

@@ -35,14 +35,13 @@ var DOMAIN_TYPE = {
 var SECRET_MASK = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
 var PUBLIC_ENV_PREFIX = "NEXT_PUBLIC_";
 var REPO_PROVIDER = {
-  FREESTYLE: "freestyle",
   CODE_STORAGE: "code_storage",
   GITHUB: "github",
   GITEA: "gitea",
   EXTERNAL: "external"
 };
 function isManagedRepoProvider(provider) {
-  return provider === REPO_PROVIDER.FREESTYLE || provider === REPO_PROVIDER.CODE_STORAGE;
+  return provider === REPO_PROVIDER.CODE_STORAGE;
 }
 var REPO_PROVIDER_VALUES = new Set(Object.values(REPO_PROVIDER));
 var TOKEN_PURPOSE = {

package/dist/chunk-MJMRIMR7.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { sha256 } from './chunk-25ZPFHLF.mjs';
+import { resolveBaseUrl, ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuthOrNull } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I7GEHLDD.mjs';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+var CONTENT_REMOTE_ENV = "CIMPLIFY_CONTENT_REMOTE";
+var CONTENT_FAKE_ROOT_ENV = "CIMPLIFY_CONTENT_FAKE_ROOT";
+var FAKE_REMOTE = "fake";
+var RESOLVE_PATH = "/v1/content/resolve";
+var BLOB_PATH = "/v1/content/blobs/";
+var RESOLUTION_FILE = "resolution.json";
+var BLOB_DIR = "blobs";
+var HttpContentRemote = class {
+  client;
+  baseUrl;
+  constructor(client, baseUrl) {
+    this.client = client;
+    this.baseUrl = baseUrl;
+  }
+  async resolve(items) {
+    const resolution = await this.client.post(RESOLVE_PATH, { items });
+    return resolution.versions;
+  }
+  async blob(digest) {
+    const url = new URL(`${BLOB_PATH}${digest}`, this.baseUrl).toString();
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Workshop has no blob ${digest} (HTTP ${response.status})`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (sha256(bytes) !== digest) {
+      throw new CliError(CLI_ERROR_CODE.NETWORK_ERROR, `the Workshop blob ${digest} did not match its digest`);
+    }
+    return bytes;
+  }
+};
+var DirectoryContentRemote = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  async resolve(items) {
+    const file = path.join(this.root, RESOLUTION_FILE);
+    if (!existsSync(file)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop at ${this.root} has no ${RESOLUTION_FILE}`);
+    const all = JSON.parse(readFileSync(file, "utf8"));
+    const wanted = new Set(items.map((i) => i.item));
+    const chosen = /* @__PURE__ */ new Map();
+    const queue = all.filter((v) => wanted.has(v.item));
+    for (const item of wanted) {
+      if (!queue.some((v) => v.item === item)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop has no ${item}`);
+    }
+    while (queue.length > 0) {
+      const next = queue.shift();
+      if (chosen.has(next.item)) continue;
+      chosen.set(next.item, { ...next, requested: wanted.has(next.item) });
+      const manifest = JSON.parse((await this.blob(next.version_digest)).toString("utf8"));
+      for (const dependency of manifest.dependencies ?? []) {
+        const found = all.find((v) => v.version_digest === dependency.version_digest);
+        if (found !== void 0) queue.push(found);
+      }
+    }
+    return [...chosen.values()];
+  }
+  async blob(digest) {
+    const file = path.join(this.root, BLOB_DIR, digest);
+    if (!existsSync(file)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop has no blob ${digest}`);
+    return readFileSync(file);
+  }
+};
+async function contentRemoteFromEnv() {
+  if (process.env[CONTENT_REMOTE_ENV] === FAKE_REMOTE) {
+    const root = process.env[CONTENT_FAKE_ROOT_ENV];
+    if (root === void 0 || root.length === 0) {
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${CONTENT_REMOTE_ENV}=${FAKE_REMOTE} needs ${CONTENT_FAKE_ROOT_ENV} to name a local Workshop directory`);
+    }
+    return new DirectoryContentRemote(root);
+  }
+  const auth = await readAuthOrNull();
+  const baseUrl = auth?.apiBaseUrl ?? resolveBaseUrl();
+  return new HttpContentRemote(auth === null ? ApiClient.unauthenticated(baseUrl) : ApiClient.fromAuth(auth), baseUrl);
+}
+
+export { contentRemoteFromEnv };