@dreamboard-games/cli 0.1.30-alpha.0 → 0.1.30-alpha.2

package/dist/agent-verifier/chunk-6UUJEYDV.mjs

@@ -1,213 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/repo-root.ts
-import { existsSync } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-function isRepoRoot(candidate) {
-  return existsSync(path.join(candidate, "pnpm-workspace.yaml")) && existsSync(path.join(candidate, "apps", "dreamboard-cli", "package.json"));
-}
-function resolveCliRepoRoot(importMetaUrl = import.meta.url) {
-  let current = path.dirname(fileURLToPath(importMetaUrl));
-  while (true) {
-    if (isRepoRoot(current)) {
-      return current;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  throw new Error(
-    `Could not resolve Dreamboard CLI repo root from ${importMetaUrl}.`
-  );
-}
-
-// src/utils/repo-local-package-resolution.ts
-import { existsSync as existsSync2, readdirSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import path2 from "path";
-var PACKAGE_INFO_CACHE = /* @__PURE__ */ new Map();
-function normalizeRepoRoot(options) {
-  return options?.repoRoot ?? resolveCliRepoRoot(import.meta.url);
-}
-function readPackageInfos(repoRoot) {
-  const cached = PACKAGE_INFO_CACHE.get(repoRoot);
-  if (cached) {
-    return cached;
-  }
-  const packageInfos = /* @__PURE__ */ new Map();
-  const addPackageInfo = (packageRoot) => {
-    const packageJsonPath = path2.join(packageRoot, "package.json");
-    if (!existsSync2(packageJsonPath)) {
-      return;
-    }
-    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    if (!parsed.name || !parsed.name.startsWith("@dreamboard/") && !parsed.name.startsWith("@dreamboard-games/") || parsed.exports === void 0) {
-      return;
-    }
-    packageInfos.set(parsed.name, {
-      rootDir: packageRoot,
-      exports: parsed.exports
-    });
-  };
-  for (const workspaceDirName of ["packages", "apps"]) {
-    const workspaceRoot = path2.join(repoRoot, workspaceDirName);
-    if (!existsSync2(workspaceRoot)) {
-      continue;
-    }
-    for (const entry of readdirSync(workspaceRoot, { withFileTypes: true })) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      addPackageInfo(path2.join(workspaceRoot, entry.name));
-    }
-  }
-  for (const nodeModulesRoot of [
-    path2.join(repoRoot, "node_modules"),
-    path2.join(repoRoot, "apps", "dreamboard-cli", "node_modules")
-  ]) {
-    for (const scopeName of ["@dreamboard", "@dreamboard-games"]) {
-      const scopeRoot = path2.join(nodeModulesRoot, scopeName);
-      if (!existsSync2(scopeRoot)) {
-        continue;
-      }
-      for (const entry of readdirSync(scopeRoot, { withFileTypes: true })) {
-        if (!entry.isDirectory() && !entry.isSymbolicLink()) {
-          continue;
-        }
-        addPackageInfo(path2.join(scopeRoot, entry.name));
-      }
-    }
-  }
-  PACKAGE_INFO_CACHE.set(repoRoot, packageInfos);
-  return packageInfos;
-}
-function parseDreamboardPackageSpecifier(specifier) {
-  if (!specifier.startsWith("@dreamboard/") && !specifier.startsWith("@dreamboard-games/")) {
-    return null;
-  }
-  const segments = specifier.split("/");
-  if (segments.length < 2) {
-    return null;
-  }
-  const packageName = `${segments[0]}/${segments[1]}`;
-  const subpath = segments.length === 2 ? "." : `./${segments.slice(2).join("/")}`;
-  return { packageName, subpath };
-}
-function resolveSourceTarget(exportEntry) {
-  if (typeof exportEntry === "string") {
-    return exportEntry;
-  }
-  if (typeof exportEntry === "object" && exportEntry !== null && "dreamboard-source" in exportEntry && typeof exportEntry["dreamboard-source"] === "string") {
-    return exportEntry["dreamboard-source"];
-  }
-  if (typeof exportEntry === "object" && exportEntry !== null && "bun" in exportEntry && typeof exportEntry.bun === "string") {
-    return exportEntry.bun;
-  }
-  if (typeof exportEntry === "object" && exportEntry !== null && "import" in exportEntry && typeof exportEntry.import === "string") {
-    return exportEntry.import;
-  }
-  return null;
-}
-function resolveSourceTargetForSubpath(options) {
-  if (typeof options.exportsField !== "object" || options.exportsField === null || Array.isArray(options.exportsField)) {
-    return options.subpath === "." ? resolveSourceTarget(options.exportsField) : null;
-  }
-  const exportsMap = options.exportsField;
-  if (options.subpath === ".") {
-    return resolveSourceTarget(exportsMap["."]) ?? resolveSourceTarget(exportsMap);
-  }
-  const exactTarget = resolveSourceTarget(exportsMap[options.subpath]);
-  if (exactTarget) {
-    return exactTarget;
-  }
-  const wildcardEntries = Object.entries(exportsMap).filter(([key]) => key.includes("*")).sort(([left], [right]) => right.length - left.length);
-  for (const [pattern, exportEntry] of wildcardEntries) {
-    const starIndex = pattern.indexOf("*");
-    const prefix = pattern.slice(0, starIndex);
-    const suffix = pattern.slice(starIndex + 1);
-    if (!options.subpath.startsWith(prefix) || !options.subpath.endsWith(suffix)) {
-      continue;
-    }
-    const wildcardValue = options.subpath.slice(
-      prefix.length,
-      options.subpath.length - suffix.length
-    );
-    const targetPattern = resolveSourceTarget(exportEntry);
-    if (!targetPattern) {
-      continue;
-    }
-    return targetPattern.replace("*", wildcardValue);
-  }
-  return null;
-}
-function resolveRepoLocalPackageSource(specifier, options) {
-  const parsedSpecifier = parseDreamboardPackageSpecifier(specifier);
-  if (!parsedSpecifier) {
-    return null;
-  }
-  let repoRoot;
-  try {
-    repoRoot = normalizeRepoRoot(options);
-  } catch {
-    return null;
-  }
-  const packageInfo = readPackageInfos(repoRoot).get(
-    parsedSpecifier.packageName
-  );
-  if (!packageInfo) {
-    return null;
-  }
-  const sourceTarget = resolveSourceTargetForSubpath({
-    exportsField: packageInfo.exports,
-    subpath: parsedSpecifier.subpath
-  });
-  if (!sourceTarget) {
-    return null;
-  }
-  return path2.join(packageInfo.rootDir, sourceTarget);
-}
-var cliPackageRequire = createRequire(import.meta.url);
-function resolvableFromDirectory(specifier, directory) {
-  try {
-    createRequire(path2.join(directory, "noop.js")).resolve(specifier);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveCliBundledPackage(specifier) {
-  try {
-    return cliPackageRequire.resolve(specifier);
-  } catch {
-    return null;
-  }
-}
-function createRepoLocalPackageResolutionPlugin(options) {
-  return {
-    name: "dreamboard-repo-local-package-resolution",
-    setup(build) {
-      build.onResolve({ filter: /^@dreamboard(?:-games)?\// }, (args) => {
-        const resolvedPath = resolveRepoLocalPackageSource(args.path, options);
-        if (resolvedPath) {
-          return { path: resolvedPath };
-        }
-        if (resolvableFromDirectory(args.path, args.resolveDir)) {
-          return null;
-        }
-        const bundledPath = resolveCliBundledPackage(args.path);
-        if (bundledPath) {
-          return { path: bundledPath };
-        }
-        return null;
-      });
-    }
-  };
-}
-
-export {
-  resolveCliRepoRoot,
-  createRepoLocalPackageResolutionPlugin
-};

package/dist/agent-verifier/chunk-7653FPGJ.mjs

@@ -1,381 +0,0 @@
-#!/usr/bin/env node
-import {
-  FRAMEWORK_PNPM_OVERRIDES
-} from "./chunk-RBDDIIPM.mjs";
-import {
-  DEFAULT_WEB_BASE_URL
-} from "./chunk-SHUMAVAP.mjs";
-
-// src/services/project/workspace-dependencies.ts
-import crypto from "crypto";
-import { spawn } from "child_process";
-import "events";
-import { existsSync } from "fs";
-import { mkdir, lstat, readFile, rm, writeFile } from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-
-// src/services/project/dependency-tooling-messages.ts
-var DEPENDENCY_SETUP_DOCS_PATH = "/docs/reference/dependency-setup";
-var DEPENDENCY_SETUP_DOCS_URL = `${DEFAULT_WEB_BASE_URL}${DEPENDENCY_SETUP_DOCS_PATH}`;
-function buildMissingDependencyToolingMessage() {
-  return [
-    "Dreamboard needs dependency tooling to finish `dreamboard sync`.",
-    "Use Node 24+ with Corepack enabled, then run `dreamboard sync` again.",
-    "If Corepack is unavailable on this machine, install pnpm globally with `npm install -g pnpm`.",
-    `Help: ${DEPENDENCY_SETUP_DOCS_URL}`
-  ].join("\n");
-}
-function buildPackageLockConflictMessage() {
-  return [
-    "Dreamboard manages workspace dependencies during `dreamboard sync`.",
-    "This workspace has an npm lockfile that conflicts with Dreamboard-managed dependencies.",
-    "Remove `package-lock.json` and run `dreamboard sync` again.",
-    `Help: ${DEPENDENCY_SETUP_DOCS_URL}`
-  ].join("\n");
-}
-function buildMissingGeneratedLockfileMessage() {
-  return [
-    "Dreamboard could not finish preparing workspace dependencies during `dreamboard sync`.",
-    "Diagnostic: `pnpm-lock.yaml` was not created.",
-    `Help: ${DEPENDENCY_SETUP_DOCS_URL}`
-  ].join("\n");
-}
-function buildDependencyPreparationFailureMessage(options) {
-  const details = options.output?.trim();
-  return [
-    `Dreamboard could not finish preparing workspace dependencies during \`dreamboard sync\`${options.exitCode != null ? ` (exit code ${options.exitCode})` : ""}.`,
-    details ? `Diagnostic output:
-${details}` : null,
-    `Help: ${DEPENDENCY_SETUP_DOCS_URL}`
-  ].filter(Boolean).join("\n");
-}
-
-// src/services/project/workspace-dependencies.ts
-var MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-var CLI_ROOT = path.resolve(MODULE_DIR, "../../..");
-var REPO_ROOT = path.resolve(CLI_ROOT, "../..");
-var REPO_PACKAGE_JSON_PATH = path.join(REPO_ROOT, "package.json");
-var DEFAULT_PACKAGE_MANAGER = "pnpm@10.4.1";
-var SDK_PACKAGE_NAME = "@dreamboard-games/sdk";
-var SDK_REQUIRED_DIST_FILES = [
-  "dist/index.d.ts",
-  "dist/index.js",
-  "dist/types.d.ts",
-  "dist/types.js",
-  "dist/ui.d.ts",
-  "dist/ui.js",
-  "dist/runtime.d.ts",
-  "dist/runtime.js"
-];
-var DEPENDENCY_INSTALL_METADATA_PATH_SEGMENTS = [
-  ".dreamboard",
-  "dependency-install.json"
-];
-var LockfileGenerationError = class extends Error {
-  constructor(binary, details) {
-    super(buildLockfileGenerationErrorMessage(binary, details), {
-      cause: details.cause
-    });
-    this.binary = binary;
-    this.details = details;
-    this.name = "LockfileGenerationError";
-  }
-  binary;
-  details;
-};
-async function generatePnpmLockfile(projectRoot, _options = {}) {
-  await ensurePackageManagerNormalized(projectRoot);
-  await assertNoNpmLockfileConflict(projectRoot);
-  await runPackageManagerCommand(projectRoot, {
-    args: [
-      "install",
-      "--ignore-workspace",
-      "--lockfile-only",
-      "--config.shared-workspace-lockfile=false"
-    ]
-  });
-  await assertPnpmLockfilePresent(projectRoot);
-  return true;
-}
-async function installWorkspaceDependencies(projectRoot, _options = {}) {
-  const result = await reconcileWorkspaceDependencies(projectRoot);
-  return result.required;
-}
-async function reconcileWorkspaceDependencies(projectRoot) {
-  const packageJsonPath = path.join(projectRoot, "package.json");
-  if (!await pathExists(packageJsonPath)) {
-    return {
-      required: false,
-      installed: false,
-      lockfileGenerated: false,
-      packageManagerNormalized: false,
-      fingerprint: null
-    };
-  }
-  await assertNoNpmLockfileConflict(projectRoot);
-  const packageManagerNormalized = await ensurePackageManagerNormalized(projectRoot);
-  const pnpmLockfilePath = path.join(projectRoot, "pnpm-lock.yaml");
-  const nodeModulesPath = path.join(projectRoot, "node_modules");
-  const metadataPath = path.join(
-    projectRoot,
-    ...DEPENDENCY_INSTALL_METADATA_PATH_SEGMENTS
-  );
-  let lockfileGenerated = false;
-  let installed = false;
-  const metadata = await readJsonFile(metadataPath);
-  const lockfileExists = await pathExists(pnpmLockfilePath);
-  if (!lockfileExists) {
-    await runPackageManagerCommand(projectRoot, {
-      args: [
-        "install",
-        "--ignore-workspace",
-        "--config.shared-workspace-lockfile=false"
-      ]
-    });
-    lockfileGenerated = true;
-    installed = true;
-  }
-  await assertPnpmLockfilePresent(projectRoot);
-  let fingerprint = await fingerprintInstallManifest({
-    packageJsonPath,
-    lockfilePath: pnpmLockfilePath
-  });
-  const hasValidInstalledDeps = await pathExists(nodeModulesPath) && await hasValidInstalledDependencies({
-    packageJsonPath,
-    nodeModulesPath
-  });
-  const shouldInstall = !installed && (metadata?.dependencyFingerprint !== fingerprint || !hasValidInstalledDeps);
-  if (shouldInstall) {
-    await rm(nodeModulesPath, { recursive: true, force: true });
-    await runPackageManagerCommand(projectRoot, {
-      args: [
-        "install",
-        "--ignore-workspace",
-        "--config.shared-workspace-lockfile=false"
-      ]
-    });
-    installed = true;
-    fingerprint = await fingerprintInstallManifest({
-      packageJsonPath,
-      lockfilePath: pnpmLockfilePath
-    });
-  }
-  if (installed || packageManagerNormalized || !metadata) {
-    await mkdir(path.dirname(metadataPath), { recursive: true });
-    await writeJsonFile(metadataPath, {
-      dependencyFingerprint: fingerprint,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      packageManager: await readRepoPackageManager()
-    });
-  }
-  return {
-    required: true,
-    installed,
-    lockfileGenerated,
-    packageManagerNormalized,
-    fingerprint
-  };
-}
-async function assertNoNpmLockfileConflict(projectRoot) {
-  const packageLockPath = path.join(projectRoot, "package-lock.json");
-  const pnpmLockPath = path.join(projectRoot, "pnpm-lock.yaml");
-  if (await pathExists(packageLockPath) && !await pathExists(pnpmLockPath)) {
-    throw new Error(buildPackageLockConflictMessage());
-  }
-}
-async function assertPnpmLockfilePresent(projectRoot) {
-  const pnpmLockfilePath = path.join(projectRoot, "pnpm-lock.yaml");
-  if (!await pathExists(pnpmLockfilePath)) {
-    throw new Error(buildMissingGeneratedLockfileMessage());
-  }
-}
-async function ensurePackageManagerNormalized(projectRoot) {
-  const packageJsonPath = path.join(projectRoot, "package.json");
-  const packageJsonContent = await readFile(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(packageJsonContent);
-  const packageManager = await readRepoPackageManager();
-  const nextPackageJson = {
-    ...packageJson,
-    packageManager,
-    pnpm: mergePnpmConfig(packageJson.pnpm)
-  };
-  const normalizedPackageJson = `${JSON.stringify(nextPackageJson, null, 2)}
-`;
-  if (normalizedPackageJson === packageJsonContent) {
-    return false;
-  }
-  await writeFile(packageJsonPath, normalizedPackageJson, "utf8");
-  return true;
-}
-function mergePnpmConfig(existingPnpm) {
-  const existingOverrides = existingPnpm?.overrides && typeof existingPnpm.overrides === "object" && !Array.isArray(existingPnpm.overrides) ? existingPnpm.overrides : {};
-  return {
-    ...existingPnpm ?? {},
-    overrides: {
-      ...existingOverrides,
-      ...FRAMEWORK_PNPM_OVERRIDES
-    }
-  };
-}
-async function fingerprintInstallManifest(options) {
-  const packageJson = await readFile(options.packageJsonPath, "utf8");
-  const lockfile = await readFile(options.lockfilePath, "utf8");
-  const packageManager = await readRepoPackageManager();
-  return fingerprintContent([
-    packageJson,
-    lockfile,
-    `packageManager:${packageManager}`
-  ]);
-}
-async function hasValidInstalledDependencies(options) {
-  const packageJson = await readJsonFile(
-    options.packageJsonPath
-  );
-  if (!packageJson) {
-    return false;
-  }
-  const directDependencyNames = /* @__PURE__ */ new Set();
-  for (const field of [
-    "dependencies",
-    "devDependencies",
-    "optionalDependencies"
-  ]) {
-    for (const packageName of Object.keys(packageJson[field] ?? {})) {
-      directDependencyNames.add(packageName);
-    }
-  }
-  if (directDependencyNames.size === 0) {
-    return true;
-  }
-  for (const packageName of directDependencyNames) {
-    const packageRoot = path.join(
-      options.nodeModulesPath,
-      ...packageName.split("/")
-    );
-    if (!await pathExists(path.join(packageRoot, "package.json"))) {
-      return false;
-    }
-    if (packageName === SDK_PACKAGE_NAME && !await hasInstalledSdkDistFiles(packageRoot)) {
-      return false;
-    }
-  }
-  return true;
-}
-async function hasInstalledSdkDistFiles(packageRoot) {
-  for (const relativePath of SDK_REQUIRED_DIST_FILES) {
-    if (!await pathExists(path.join(packageRoot, relativePath))) {
-      return false;
-    }
-  }
-  return true;
-}
-function hasExactPnpmVersion(value) {
-  return /^pnpm@\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(value ?? "");
-}
-async function readRepoPackageManager() {
-  const packageJson = await readJsonFile(
-    REPO_PACKAGE_JSON_PATH
-  );
-  const packageManager = packageJson?.packageManager?.trim();
-  return hasExactPnpmVersion(packageManager) ? packageManager : DEFAULT_PACKAGE_MANAGER;
-}
-function fingerprintContent(parts) {
-  return crypto.createHash("sha256").update(parts.join("\n---\n")).digest("hex");
-}
-function resolvePnpmInstallInvocation(installArgs) {
-  const corepackPath = path.join(path.dirname(process.execPath), "corepack");
-  if (existsSync(corepackPath)) {
-    return { command: corepackPath, args: ["pnpm", ...installArgs] };
-  }
-  return { command: "pnpm", args: [...installArgs] };
-}
-async function runPackageManagerCommand(projectRoot, command) {
-  const invocation = resolvePnpmInstallInvocation(command.args);
-  await runLockfileCommand(projectRoot, {
-    binary: invocation.command,
-    args: invocation.args
-  });
-}
-async function runLockfileCommand(projectRoot, command) {
-  await new Promise((resolve, reject) => {
-    const child = spawn(command.binary, command.args, {
-      cwd: projectRoot,
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    bindStream(child.stdout, (chunk) => {
-      stdout += chunk.toString();
-    });
-    bindStream(child.stderr, (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (cause) => {
-      reject(
-        new LockfileGenerationError(command.binary, {
-          stdout,
-          stderr,
-          cause
-        })
-      );
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve();
-        return;
-      }
-      reject(
-        new LockfileGenerationError(command.binary, {
-          code,
-          stdout,
-          stderr
-        })
-      );
-    });
-  });
-}
-function buildLockfileGenerationErrorMessage(binary, details) {
-  if (details.cause) {
-    const errnoError = details.cause;
-    const binaryName = path.basename(binary).toLowerCase();
-    if (errnoError.code === "ENOENT" && (binaryName === "pnpm" || binaryName === "pnpm.cmd" || binaryName === "corepack" || binaryName === "corepack.exe")) {
-      return buildMissingDependencyToolingMessage();
-    }
-    return `Failed to start ${binary} for Dreamboard dependency reconciliation. ${details.cause.message}`;
-  }
-  const output = [details.stdout.trim(), details.stderr.trim()].filter((chunk) => chunk.length > 0).join("\n");
-  return buildDependencyPreparationFailureMessage({
-    exitCode: details.code,
-    output
-  });
-}
-async function pathExists(targetPath) {
-  try {
-    await lstat(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readJsonFile(filePath) {
-  try {
-    return JSON.parse(await readFile(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-async function writeJsonFile(filePath, value) {
-  await writeFile(filePath, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function bindStream(stream, onData) {
-  stream?.on("data", onData);
-}
-
-export {
-  generatePnpmLockfile,
-  installWorkspaceDependencies,
-  reconcileWorkspaceDependencies
-};