@skaile/workspaces 5.11.0 → 5.13.0

package/dist/chunk-FB3NREF7.js

@@ -0,0 +1,649 @@
+import { openLibrary } from './chunk-VLBIME5L.js';
+import { S, logErr, logWarn, logOk, logInfo } from './chunk-PYTTF754.js';
+import { getKindRegistry } from './chunk-4NJ3QQHZ.js';
+import { stampManifestPublisher, upsertManifestAsset, resolveIndexPath, LocalIndex } from './chunk-DKGEV6SQ.js';
+import { requiresSyntaxErrors } from './chunk-NVO6WECE.js';
+import { matchPin } from './chunk-L3ZGYSWY.js';
+import { globalSkaileDir } from './chunk-L5VSIPQD.js';
+import { SKAILE_MANIFEST_FILENAME, listLibrarySymlinks, librarySymlinkMessage, loadSkPublishManifest } from './chunk-IY5E7Y5W.js';
+import { parseFrontmatter } from './chunk-M3P4BYRK.js';
+import { parseDep, isValidPublisher, slugifyAssetName, PUBLISHER_HINT } from './chunk-J4OYIYFQ.js';
+import * as fs from 'fs';
+import { rmSync, readFileSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import * as path from 'path';
+import { join, dirname } from 'path';
+import { Option } from 'commander';
+import { parse, stringify } from 'yaml';
+import { randomBytes, createHash } from 'crypto';
+
+// cli/src/commands/publish-core.ts
+function formatNamespaceAvailability(a) {
+  switch (a.status) {
+    case "owned-by-you":
+    case "available":
+      return `${S.ok("\u2713")} ${a.message}`;
+    case "claimable-by-you":
+      return `${S.warn("!")} ${a.message}`;
+    default:
+      return `${S.err("\u2717")} ${a.message}`;
+  }
+}
+async function preflightNamespace(client, namespace) {
+  let a;
+  try {
+    a = await client.namespaceAvailability(namespace);
+  } catch {
+    return { ok: true };
+  }
+  switch (a.status) {
+    case "owned-by-you":
+    case "available":
+      return { ok: true };
+    case "claimable-by-you":
+      return {
+        ok: false,
+        message: `@${namespace} isn't yours yet \u2014 claim it in the store first${a.claimMethod ? ` (${a.claimMethod})` : ""}, then re-run. ${a.message}`
+      };
+    default:
+      return { ok: false, message: `Cannot publish under @${namespace} \u2014 ${a.message}` };
+  }
+}
+function matchCandidatesToManifest(candidates, manifest) {
+  const wanted = new Set((manifest.assets ?? []).map((a) => `${a.kind}:${a.name}`));
+  return candidates.filter((c) => wanted.has(`${c.kind}:${c.name}`));
+}
+function refFor(kind, publisher, name, version) {
+  const base = `${kind}:@${publisher}/${name}`;
+  return version ? `${base}#${version}` : base;
+}
+var UNSET_NAMESPACE = "<manifest publisher>";
+function assetNamespace(asset, manifest) {
+  return asset.publisher ?? manifest.publisher;
+}
+function assetEntryRef(asset, manifest) {
+  const ns = assetNamespace(asset, manifest);
+  return ns ? refFor(asset.kind, ns, asset.name) : `${asset.kind}:${asset.name}`;
+}
+function manifestVersionMismatchMessage(entryRef, entryVersion, relFile, fileVersion) {
+  return `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${entryRef}: manifest version ${entryVersion} differs from ${relFile} (${fileVersion}). The file is the source of truth: bump the version there, then run \`skaile library index <library>\`.`;
+}
+function manifestNamespaces(manifest, assetName) {
+  const out = /* @__PURE__ */ new Set();
+  for (const a of manifest.assets ?? []) {
+    if (assetName && a.name !== assetName) continue;
+    const ns = assetNamespace(a, manifest);
+    if (ns) out.add(ns);
+  }
+  if (out.size === 0 && manifest.publisher) out.add(manifest.publisher);
+  return [...out];
+}
+function plannedRefs(manifest, assetName) {
+  return (manifest.assets ?? []).filter((a) => !assetName || a.name === assetName).map(
+    (a) => refFor(
+      a.kind,
+      assetNamespace(a, manifest) ?? UNSET_NAMESPACE,
+      a.name,
+      a.version ?? manifest.version
+    )
+  );
+}
+function bareName(ref) {
+  const afterKind = ref.includes(":") ? ref.slice(ref.indexOf(":") + 1) : ref;
+  const afterScope = afterKind.includes("/") ? afterKind.slice(afterKind.indexOf("/") + 1) : afterKind;
+  return afterScope.split("#")[0];
+}
+function exitOnEmptyAsset(asset) {
+  if (asset !== void 0 && asset.trim() === "") {
+    logErr(
+      "--asset needs a ref (`kind:@publisher/name[#version]` or a name); it is empty. Drop the option to select every asset."
+    );
+    process.exit(1);
+  }
+}
+async function pollJob(client, jobId, intervalMs = 1500, timeoutMs = 6e4) {
+  const deadline = Date.now() + timeoutMs;
+  let job = await client.jobGet(jobId);
+  while (job.status === "running" && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, intervalMs));
+    job = await client.jobGet(jobId);
+  }
+  return job;
+}
+function isDupSourceError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return /\b409\b|conflict|duplicate|already exists|already registered|unique/.test(msg);
+}
+async function publishToStore(opts) {
+  const { sourceUrl, ref, sidecar, manifest, assetName, client: pub } = opts;
+  let sourceId;
+  try {
+    const added = await pub.sourcesAdd({
+      url: sourceUrl,
+      ref,
+      ...sidecar ? { sidecarUrl: sidecar.url, sidecarRef: sidecar.ref } : {},
+      // Publish under the manifest's declared namespace; the store resolves a
+      // claimed Publisher when it differs from the caller's login, else defaults
+      // to `@<username>`. Omitted when the manifest carries no publisher.
+      ...manifest.publisher ? { namespace: manifest.publisher } : {}
+    });
+    sourceId = added.id;
+  } catch (err) {
+    if (!isDupSourceError(err)) throw err;
+    const rows = await pub.sourcesList();
+    const found = rows.find((r) => r.url === sourceUrl);
+    if (!found) {
+      throw new Error(
+        `Source ${sourceUrl} looked already-registered but no owned row matched: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    sourceId = found.id;
+  }
+  const { jobId } = await pub.sourceSync(sourceId);
+  const job = await pollJob(pub, jobId);
+  if (job.status === "failed" || job.status === "cancelled") {
+    const failed = (job.items ?? []).filter((i) => i.status === "failed");
+    for (const i of failed) logErr(`sync: ${i.label}: ${i.error ?? "failed"}`);
+    logErr(`Source sync ${job.status}.`);
+    process.exit(1);
+  }
+  if (job.status === "running") {
+    logErr("Source sync timed out before completing \u2014 re-run `publish`, or check the store.");
+    process.exit(1);
+  }
+  let candidates = matchCandidatesToManifest(await pub.sourceCandidates(sourceId), manifest);
+  if (assetName) candidates = candidates.filter((c) => c.name === assetName);
+  if (candidates.length === 0) {
+    logWarn("No candidates discovered \u2014 check the manifest and the source ref.");
+    process.exit(1);
+  }
+  const published = [];
+  for (const c of candidates) {
+    try {
+      const preview = await pub.assetPreview(c.id);
+      const res = await pub.assetPublish(c.id, { ref, files: preview.discoveredFiles });
+      if (res.jobId) {
+        const pubJob = await pollJob(pub, res.jobId);
+        if (pubJob.status !== "succeeded") {
+          const errs = (pubJob.items ?? []).filter((i) => i.status === "failed").map((i) => i.error).filter(Boolean);
+          logWarn(
+            `Publish of ${c.kind}:${c.name} did not succeed (${pubJob.status})` + (errs.length ? `: ${errs.join("; ")}` : "")
+          );
+          continue;
+        }
+      }
+      published.push(refFor(c.kind, preview.candidate.publisherNamespace, c.name, c.version));
+    } catch (err) {
+      logWarn(
+        `Failed to publish ${c.kind}:${c.name}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  logOk(`Published ${published.length} asset(s):`);
+  for (const r of published) logInfo(`  ${r}`);
+  return { published };
+}
+function makePkcePair() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function loadStoreAuthConfig() {
+  return {
+    keycloakUrl: trimTrailingSlash(process.env.SKAILE_KEYCLOAK_URL ?? "https://auth.skaile.ai"),
+    realm: process.env.SKAILE_STORE_REALM ?? "skaile-store",
+    clientId: process.env.SKAILE_STORE_CLI_CLIENT ?? "skaile-store-cli",
+    authFile: process.env.SKAILE_AUTH_FILE ?? join(globalSkaileDir(), "auth.json")
+  };
+}
+function oidc(config) {
+  const base = `${config.keycloakUrl}/realms/${config.realm}/protocol/openid-connect`;
+  return { deviceAuth: `${base}/auth/device`, token: `${base}/token` };
+}
+var EXPIRY_MARGIN_MS = 3e4;
+function readAuth(config) {
+  try {
+    const parsed = JSON.parse(readFileSync(config.authFile, "utf-8"));
+    if (parsed && typeof parsed.access_token === "string") return parsed;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getStoreIdentity(config = loadStoreAuthConfig()) {
+  const auth = readAuth(config);
+  if (!auth) return null;
+  try {
+    const payload = auth.access_token.split(".")[1];
+    const json = JSON.parse(Buffer.from(payload, "base64url").toString("utf-8"));
+    const username = typeof json.preferred_username === "string" ? json.preferred_username : void 0;
+    const githubLogin = typeof json.github_login === "string" ? json.github_login : void 0;
+    return username || githubLogin ? { username, githubLogin } : null;
+  } catch {
+    return null;
+  }
+}
+function writeAuth(config, auth) {
+  mkdirSync(dirname(config.authFile), { recursive: true });
+  writeFileSync(config.authFile, JSON.stringify(auth, null, 2), { mode: 384 });
+  chmodSync(config.authFile, 384);
+}
+function logout(config) {
+  try {
+    rmSync(config.authFile);
+  } catch {
+  }
+}
+function hasStoredAuth(config) {
+  return readAuth(config) !== null;
+}
+function tokenToStored(token) {
+  return {
+    access_token: token.access_token,
+    refresh_token: token.refresh_token,
+    expires_at: Date.now() + (token.expires_in ?? 300) * 1e3 - EXPIRY_MARGIN_MS
+  };
+}
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function defaultPrompt(url, userCode) {
+  process.stderr.write(
+    `
+To sign in, open:
+
+    ${url}
+
+and enter the code: ${userCode}
+
+Waiting for approval\u2026
+`
+  );
+}
+async function deviceLogin(config, deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep = deps.sleep ?? defaultSleep;
+  const onPrompt = deps.onPrompt ?? defaultPrompt;
+  const endpoints = oidc(config);
+  const pkce = makePkcePair();
+  const deviceRes = await fetchImpl(endpoints.deviceAuth, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: config.clientId,
+      scope: "openid profile",
+      code_challenge: pkce.challenge,
+      code_challenge_method: "S256"
+    })
+  });
+  if (!deviceRes.ok) {
+    throw new Error(
+      `Device authorization request failed (${deviceRes.status}): ${await deviceRes.text()}`
+    );
+  }
+  const device = await deviceRes.json();
+  onPrompt(device.verification_uri_complete ?? device.verification_uri, device.user_code);
+  const intervalMs = (device.interval ?? 5) * 1e3;
+  const deadline = Date.now() + device.expires_in * 1e3;
+  let waitMs = intervalMs;
+  while (Date.now() < deadline) {
+    await sleep(waitMs);
+    const tokenRes = await fetchImpl(endpoints.token, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: device.device_code,
+        client_id: config.clientId,
+        code_verifier: pkce.verifier
+      })
+    });
+    const token = await tokenRes.json();
+    if (tokenRes.ok) {
+      const stored = tokenToStored(token);
+      writeAuth(config, stored);
+      return stored;
+    }
+    if (token.error === "authorization_pending") continue;
+    if (token.error === "slow_down") {
+      waitMs += 5e3;
+      continue;
+    }
+    throw new Error(`Sign-in failed: ${token.error_description ?? token.error ?? "unknown error"}`);
+  }
+  throw new Error("Sign-in timed out before approval.");
+}
+async function refresh(config, refreshToken, fetchImpl) {
+  const res = await fetchImpl(oidc(config).token, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: config.clientId
+    })
+  });
+  const token = await res.json();
+  if (!res.ok) {
+    throw new Error(
+      `Token refresh failed: ${token.error_description ?? token.error ?? res.status}`
+    );
+  }
+  const stored = tokenToStored(token);
+  writeAuth(config, stored);
+  return stored;
+}
+async function getAccessToken(config, deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const auth = readAuth(config);
+  if (!auth) throw new Error("Not signed in. Run `skaile store login` first.");
+  if (Date.now() < auth.expires_at) return auth.access_token;
+  if (!auth.refresh_token) throw new Error("Session expired. Run `skaile store login` again.");
+  try {
+    return (await refresh(config, auth.refresh_token, fetchImpl)).access_token;
+  } catch {
+    throw new Error("Session expired and refresh failed. Run `skaile store login` again.");
+  }
+}
+
+// cli/src/commands/library-index.ts
+function manifestRequiresProblems(dir) {
+  const file = path.join(dir, "skaile.manifest.yaml");
+  let doc;
+  try {
+    doc = parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return [];
+  }
+  const assets = doc?.assets;
+  if (!Array.isArray(assets)) return [];
+  const problems = [];
+  for (const a of assets) {
+    if (!a || typeof a !== "object") continue;
+    const { kind, name, dependencies } = a;
+    if (!Array.isArray(dependencies)) continue;
+    const entries = dependencies.map((d) => typeof d === "string" ? d : String(d));
+    for (const message of requiresSyntaxErrors(entries)) {
+      problems.push({
+        asset: `${String(kind)}:${String(name)}`,
+        message: `ManifestRequiresError: ${message}`
+      });
+    }
+  }
+  return problems;
+}
+async function knownAssetVersions(dir) {
+  const known = {};
+  const add = (publisher, kind, name, version) => {
+    if (!publisher) return;
+    const key = `${publisher.replace(/^@/, "")}/${kind}:${name}`;
+    const versions = known[key] ?? [];
+    if (version && !versions.includes(version)) versions.push(version);
+    known[key] = versions;
+  };
+  const addManifest = (libPath) => {
+    const manifest = loadSkPublishManifest(libPath);
+    for (const a of manifest?.assets ?? []) {
+      add(a.publisher ?? manifest?.publisher, a.kind, a.name, a.version);
+    }
+  };
+  addManifest(dir);
+  const indexPath = resolveIndexPath();
+  if (!fs.existsSync(indexPath)) return known;
+  const index = new LocalIndex({ indexPath, kindRegistry: getKindRegistry() });
+  try {
+    for (const def of await index.listAssetDefs())
+      add(def.publisher, def.kind, def.name, def.version);
+    for (const lib of await index.listSources()) {
+      if (path.resolve(lib.path) !== path.resolve(dir) && fs.existsSync(lib.path)) {
+        addManifest(lib.path);
+      }
+    }
+  } catch {
+  } finally {
+    index.close();
+  }
+  return known;
+}
+async function unresolvedManifestDependencies(dir) {
+  let doc;
+  try {
+    doc = parse(fs.readFileSync(path.join(dir, SKAILE_MANIFEST_FILENAME), "utf-8"));
+  } catch {
+    return [];
+  }
+  const assets = doc?.assets;
+  if (!Array.isArray(assets)) return [];
+  const wanted = [];
+  for (const a of assets) {
+    if (!a || typeof a !== "object") continue;
+    const { kind, name, dependencies } = a;
+    if (!Array.isArray(dependencies)) continue;
+    for (const d of dependencies) {
+      const entry = typeof d === "string" ? d : String(d);
+      if (requiresSyntaxErrors([entry]).length === 0) {
+        wanted.push({ asset: `${String(kind)}:${String(name)}`, entry });
+      }
+    }
+  }
+  if (wanted.length === 0) return [];
+  const known = await knownAssetVersions(dir);
+  const out = [];
+  for (const { asset, entry } of wanted) {
+    const dep = parseDep(entry);
+    if (!dep.publisher) continue;
+    const versions = known[`${dep.publisher}/${dep.kind}:${dep.name}`];
+    const prefix = `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${asset}: dependency "${entry}"`;
+    if (!versions) {
+      out.push(
+        `${prefix} is not held by any registered library (checked offline: this library and the local index; the store was not asked).`
+      );
+    } else if (dep.pin && versions.length > 0 && !versions.some((v) => matchPin(dep.pin, v))) {
+      out.push(
+        `${prefix} has no version matching "${dep.pin}" in any registered library (held: ${versions.join(", ")}).`
+      );
+    }
+  }
+  return out;
+}
+function invalidPublisherMessage(raw) {
+  return `Invalid publisher "${raw}": ${PUBLISHER_HINT}.`;
+}
+function requireValidPublisherOrExit(raw) {
+  const bare = raw.trim().replace(/^@/, "");
+  if (!isValidPublisher(bare)) {
+    logErr(invalidPublisherMessage(raw));
+    process.exit(1);
+  }
+  return bare;
+}
+function manifestPublisherProblems(dir) {
+  let doc;
+  try {
+    doc = parse(fs.readFileSync(path.join(dir, SKAILE_MANIFEST_FILENAME), "utf-8"));
+  } catch {
+    return [];
+  }
+  if (!doc || typeof doc !== "object") return [];
+  const { publisher, assets } = doc;
+  const problems = [];
+  const check = (value, where) => {
+    if (typeof value !== "string") return;
+    if (!isValidPublisher(value.trim().replace(/^@/, ""))) {
+      problems.push(`${SKAILE_MANIFEST_FILENAME} ${where} \u2014 ${invalidPublisherMessage(value)}`);
+    }
+  };
+  check(publisher, "[publisher]");
+  if (Array.isArray(assets)) {
+    for (const a of assets) {
+      if (!a || typeof a !== "object") continue;
+      const { kind, name, publisher: assetPublisher } = a;
+      check(assetPublisher, `[assets] ${String(kind)}:${String(name)}`);
+    }
+  }
+  return problems;
+}
+function exitOnManifestPublisherProblems(dir, libName) {
+  const problems = manifestPublisherProblems(dir);
+  if (problems.length === 0) return;
+  for (const message of problems) logErr(message);
+  logErr(
+    `Fix the publisher in ${SKAILE_MANIFEST_FILENAME} (\`skaile library set ${libName} publisher=<name>\` rewrites the library's own), then re-run.`
+  );
+  process.exit(1);
+}
+function reportLibrarySymlinks(dir, opts) {
+  const links = listLibrarySymlinks(dir, opts);
+  for (const link of links) logErr(librarySymlinkMessage(link));
+  return links.length;
+}
+function exitOnLibrarySymlinks(dir, verb) {
+  const count = reportLibrarySymlinks(dir);
+  if (count === 0) return;
+  logErr(`${count} symlink(s) in ${dir}: remove them, then re-run \`${verb}\`.`);
+  process.exit(1);
+}
+async function indexLibrary(lib, index, opts = {}) {
+  const { LocalCatalogSource } = await import('./library/index.js');
+  const own = index ?? await openLibrary();
+  try {
+    const source = new LocalCatalogSource(own, lib.id, lib.path, getKindRegistry());
+    const res = await source.sync({ exclude: opts.exclude });
+    if (res.pruned.length > 0) {
+      const lost = new Set(res.pruned);
+      for (const other of await own.listSources()) {
+        if (other.id === lib.id || other.backend !== "local" || !other.path) continue;
+        if (!fs.existsSync(other.path)) continue;
+        await new LocalCatalogSource(own, other.id, other.path, getKindRegistry()).sync({
+          only: lost
+        });
+      }
+    }
+    return {
+      assetsFound: res.assetsFound,
+      assetsUpdated: res.assetsUpdated,
+      errors: res.errors
+    };
+  } finally {
+    if (!index) own.close();
+  }
+}
+function resolveLibraryPublisherDetailed(lib, opts, storeIdentity) {
+  const bare = (p) => p.startsWith("@") ? p.slice(1) : p;
+  if (opts.publisher?.trim()) return { publisher: bare(opts.publisher.trim()), source: "flag" };
+  const declared = loadSkPublishManifest(lib.path)?.publisher?.trim();
+  if (declared) return { publisher: bare(declared), source: "manifest" };
+  const identity = (storeIdentity?.githubLogin ?? storeIdentity?.username)?.trim().toLowerCase();
+  if (identity && isValidPublisher(identity)) return { publisher: identity, source: "identity" };
+  try {
+    const slug = slugifyAssetName(lib.name).slice(0, 39).replace(/-+$/, "");
+    return { publisher: slug, source: "library-name" };
+  } catch {
+    return { publisher: "library", source: "library-name" };
+  }
+}
+function warnLibraryNameFallback(libName, resolved, hasPublisherFlag = false) {
+  if (resolved.source !== "library-name") return;
+  const setLater = `\`skaile library set ${libName} publisher=<name>\``;
+  logWarn(
+    `No publisher given and not signed in \u2014 using the library name "${resolved.publisher}" as the publisher. ` + (hasPublisherFlag ? `Pass --publisher <name> or run \`skaile store login\`; change it later with ${setLater}.` : `Run \`skaile store login\`, or change it later with ${setLater}.`)
+  );
+}
+function normalizeAssetFrontmatter(assetDir) {
+  let markerFile = ["SKILL.md", "AGENT.md", "CONTRACT.md"].map((m) => path.join(assetDir, m)).find((f) => fs.existsSync(f));
+  if (!markerFile) {
+    const promptMd = fs.readdirSync(assetDir).find((f) => f.endsWith(".prompt.md"));
+    if (promptMd) markerFile = path.join(assetDir, promptMd);
+  }
+  if (!markerFile) return;
+  try {
+    const { data, body } = parseFrontmatter(fs.readFileSync(markerFile, "utf8"));
+    const fm = stringify(data).trimEnd();
+    fs.writeFileSync(markerFile, `---
+${fm}
+---
+
+${body}
+`, "utf8");
+  } catch {
+  }
+}
+async function registerLibraryAsset(lib, index, input) {
+  const { publisher, source } = resolveLibraryPublisherDetailed(
+    lib,
+    { publisher: input.publisher },
+    getStoreIdentity()
+  );
+  warnLibraryNameFallback(lib.name, { publisher, source }, true);
+  normalizeAssetFrontmatter(input.assetDir);
+  stampManifestPublisher(lib.path, publisher);
+  upsertManifestAsset(lib.path, {
+    kind: input.kind,
+    name: input.name,
+    root: path.relative(lib.path, input.assetDir) || input.name,
+    version: input.version,
+    publisher
+  });
+  const idx = await indexLibrary(lib, index);
+  for (const e of idx.errors) logWarn(e);
+  return { publisher, ref: refFor(input.kind, publisher, input.name, input.version) };
+}
+var LIBRARY_UPGRADE_DOCS = "https://github.com/skaile-ai/workspaces/blob/main/docs/sections/cli/commands/library.md#upgrading-a-4x-library";
+var DOMAIN_REMOVED_HINT = `Domains were removed in 5.0 \u2014 delete DOMAIN.md files; group assets with .claude-plugin/marketplace.json. See ${LIBRARY_UPGRADE_DOCS}`;
+function removedDomainOption() {
+  return new Option("--domain <domain>", "Removed in 5.0").hideHelp();
+}
+function rejectRemovedDomainOption(opts) {
+  if (opts.domain === void 0) return;
+  logErr(DOMAIN_REMOVED_HINT);
+  process.exit(1);
+}
+function findFiles(root, match) {
+  const found = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+          walk(path.join(dir, entry.name));
+        }
+      } else if (match(entry.name)) {
+        found.push(path.join(dir, entry.name));
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+function countDomainFiles(root) {
+  return findFiles(root, (name) => name === "DOMAIN.md").length;
+}
+function warnIgnoredDomainFiles(root) {
+  const count = countDomainFiles(root);
+  if (count > 0) {
+    logWarn(
+      `${count} DOMAIN.md file(s) are ignored since 5.0 (domains were removed) \u2014 delete them; group assets with .claude-plugin/marketplace.json. See ${LIBRARY_UPGRADE_DOCS}`
+    );
+  }
+  return count;
+}
+function warnLegacyBundleFiles(root) {
+  const files = findFiles(root, (name) => name.endsWith(".bundle.yaml"));
+  if (files.length > 0) {
+    const shown = files.slice(0, 5).map((f) => path.relative(root, f) || f);
+    const more = files.length > shown.length ? `, +${files.length - shown.length} more` : "";
+    logWarn(
+      `${files.length} *.bundle.yaml file(s) are not scanned (the bundle kind became preset): ${shown.join(", ")}${more}. Run \`skaile migrate assets ${root} --write\` to rename them to *.preset.yaml. See ${LIBRARY_UPGRADE_DOCS}`
+    );
+  }
+  return files.length;
+}
+
+export { DOMAIN_REMOVED_HINT, assetEntryRef, assetNamespace, bareName, deviceLogin, exitOnEmptyAsset, exitOnLibrarySymlinks, exitOnManifestPublisherProblems, formatNamespaceAvailability, getAccessToken, getStoreIdentity, hasStoredAuth, indexLibrary, loadStoreAuthConfig, logout, manifestNamespaces, manifestPublisherProblems, manifestRequiresProblems, manifestVersionMismatchMessage, plannedRefs, preflightNamespace, publishToStore, refFor, registerLibraryAsset, rejectRemovedDomainOption, removedDomainOption, reportLibrarySymlinks, requireValidPublisherOrExit, resolveLibraryPublisherDetailed, unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, warnLibraryNameFallback };
+//# sourceMappingURL=chunk-FB3NREF7.js.map
+//# sourceMappingURL=chunk-FB3NREF7.js.map