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

package/dist/agent-verifier/chunk-HJFQDSTU.mjs

@@ -1,225 +0,0 @@
-#!/usr/bin/env node
-import {
-  atomicWriteFile,
-  withFileLock
-} from "./chunk-MINCYHXN.mjs";
-import {
-  ensureDir,
-  readJsonFile
-} from "./chunk-LM3OZLZG.mjs";
-import {
-  PROJECT_DIR_NAME
-} from "./chunk-SHUMAVAP.mjs";
-
-// src/config/global-config.ts
-import os2 from "os";
-import path2 from "path";
-
-// src/config/credential-store.ts
-import os from "os";
-import path from "path";
-import { promises as fs } from "fs";
-function getCredentialFilePath() {
-  return path.join(os.homedir(), PROJECT_DIR_NAME, "auth.json");
-}
-function getCredentialLockPath() {
-  return `${getCredentialFilePath()}.lock`;
-}
-async function fileRead() {
-  const filePath = getCredentialFilePath();
-  let data;
-  try {
-    data = await fs.readFile(filePath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-  if (data.trim().length === 0) {
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return null;
-  }
-  const accessToken = parsed.accessToken ?? parsed.authToken;
-  const refreshToken = parsed.refreshToken;
-  if (!accessToken && !refreshToken) return null;
-  return {
-    accessToken: accessToken || void 0,
-    refreshToken: refreshToken || void 0,
-    tokenExpiresAt: parsed.tokenExpiresAt || void 0,
-    clerkOAuthIssuer: parsed.clerkOAuthIssuer || void 0,
-    clerkOAuthClientId: parsed.clerkOAuthClientId || void 0,
-    clerkOAuthTokenUrl: parsed.clerkOAuthTokenUrl || void 0,
-    environment: parsed.environment || void 0
-  };
-}
-async function writeFilePayload(payload) {
-  await atomicWriteFile(
-    getCredentialFilePath(),
-    `${JSON.stringify(payload, null, 2)}
-`,
-    { mode: 384 }
-  );
-}
-async function fileWriteFull(creds) {
-  if (!creds.accessToken || !creds.refreshToken) {
-    throw new Error(
-      "Refusing to persist credentials with an empty accessToken or refreshToken."
-    );
-  }
-  await writeFilePayload({
-    authToken: creds.accessToken,
-    refreshToken: creds.refreshToken,
-    tokenExpiresAt: creds.tokenExpiresAt,
-    clerkOAuthIssuer: creds.clerkOAuthIssuer,
-    clerkOAuthClientId: creds.clerkOAuthClientId,
-    clerkOAuthTokenUrl: creds.clerkOAuthTokenUrl,
-    environment: creds.environment
-  });
-}
-async function fileWriteAccessOnly(accessToken) {
-  if (!accessToken) {
-    throw new Error("Refusing to persist an empty access token.");
-  }
-  await writeFilePayload({ authToken: accessToken });
-}
-async function fileClear() {
-  const filePath = getCredentialFilePath();
-  try {
-    await fs.unlink(filePath);
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-var fileCredentialBackend = {
-  name: "file",
-  read: fileRead,
-  writeFull: fileWriteFull,
-  writeAccessOnly: fileWriteAccessOnly,
-  clear: fileClear
-};
-var cachedBackend = null;
-var migrationCompleted = false;
-var backendResolver = defaultBackendResolver;
-async function defaultBackendResolver() {
-  const override = (process.env.DREAMBOARD_CREDENTIAL_BACKEND ?? "").trim().toLowerCase();
-  if (override === "file") {
-    return fileCredentialBackend;
-  }
-  if (override && override !== "keychain" && override !== "auto") {
-    throw new Error(
-      `Unknown DREAMBOARD_CREDENTIAL_BACKEND value "${override}" (expected "file", "keychain", or "auto").`
-    );
-  }
-  const useKeychain = override === "keychain" || await readCredentialBackendPreference();
-  if (!useKeychain) {
-    return fileCredentialBackend;
-  }
-  const { tryKeychainBackend } = await import("./keychain-backend-TNOPQV3Z.mjs");
-  const keychain = await tryKeychainBackend();
-  if (keychain.available) {
-    return keychain.backend;
-  }
-  return fileCredentialBackend;
-}
-async function readCredentialBackendPreference() {
-  try {
-    const { loadGlobalConfig: loadGlobalConfig2 } = await import("./global-config-WX3ZZIVU.mjs");
-    const config = await loadGlobalConfig2();
-    return config.credentialBackend === "keychain";
-  } catch {
-    return false;
-  }
-}
-async function getCredentialBackend() {
-  if (cachedBackend === null) {
-    cachedBackend = await backendResolver();
-    if (!migrationCompleted && cachedBackend.name !== "file") {
-      await migrateFromFileBackendIfNeeded(cachedBackend);
-    }
-    migrationCompleted = true;
-  }
-  return cachedBackend;
-}
-async function migrateFromFileBackendIfNeeded(target) {
-  try {
-    const [onDisk, onTarget] = await Promise.all([
-      fileCredentialBackend.read(),
-      target.read()
-    ]);
-    if (!onDisk) return;
-    if (onTarget) {
-      await fileCredentialBackend.clear();
-      return;
-    }
-    if (onDisk.accessToken && onDisk.refreshToken) {
-      await target.writeFull({
-        accessToken: onDisk.accessToken,
-        refreshToken: onDisk.refreshToken
-      });
-    } else if (onDisk.accessToken) {
-      await target.writeAccessOnly(onDisk.accessToken);
-    } else {
-      return;
-    }
-    await fileCredentialBackend.clear();
-  } catch {
-  }
-}
-async function getStoredSession() {
-  const backend = await getCredentialBackend();
-  return backend.read();
-}
-async function setCredentials(creds) {
-  await withFileLock(getCredentialLockPath(), async () => {
-    const backend = await getCredentialBackend();
-    await backend.writeFull(creds);
-  });
-}
-
-// src/config/global-config.ts
-function normalizeCredentialBackend(value) {
-  if (value === "file" || value === "keychain") return value;
-  return void 0;
-}
-function getGlobalConfigPath() {
-  return path2.join(os2.homedir(), PROJECT_DIR_NAME, "config.json");
-}
-function getGlobalAuthPath() {
-  return getCredentialFilePath();
-}
-async function loadGlobalConfig() {
-  const config = await readJsonFile(getGlobalConfigPath()).catch(
-    () => ({})
-  );
-  return {
-    environment: config.environment,
-    credentialBackend: normalizeCredentialBackend(config.credentialBackend)
-  };
-}
-async function saveGlobalConfig(config) {
-  const configDir = path2.join(os2.homedir(), PROJECT_DIR_NAME);
-  await ensureDir(configDir);
-  const normalized = {
-    environment: config.environment,
-    credentialBackend: normalizeCredentialBackend(config.credentialBackend)
-  };
-  await atomicWriteFile(
-    getGlobalConfigPath(),
-    `${JSON.stringify(normalized, null, 2)}
-`,
-    { mode: 384 }
-  );
-}
-
-export {
-  getStoredSession,
-  setCredentials,
-  getGlobalConfigPath,
-  getGlobalAuthPath,
-  loadGlobalConfig,
-  saveGlobalConfig
-};

package/dist/agent-verifier/chunk-LI3ZR3BI.mjs

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-
-// ../../node_modules/.pnpm/@dreamboard-games+sdk@0.4.0-alpha.0_@types+react-dom@19.2.3_@types+react@19.2.17__@type_b74cbe125b074769500a56e94fa7f664/node_modules/@dreamboard-games/sdk/dist/chunk-3OZMHZK3.js
-var DEFAULT_REMEDY_BY_ARTIFACT = {
-  "base-states": "run `dreamboard test generate`, then re-run the tests.",
-  "session-state": "reset the dev session or run `dreamboard test generate`."
-};
-function artifactLabel(artifact) {
-  return artifact === "base-states" ? "base states" : "session state";
-}
-function artifactVerb(artifact) {
-  return artifact === "base-states" ? "were" : "was";
-}
-var StaleContractArtifactError = class extends Error {
-  code = "STALE_CONTRACT_ARTIFACT";
-  artifact;
-  expected;
-  found;
-  remedy;
-  constructor(options) {
-    const remedy = options.remedy ?? DEFAULT_REMEDY_BY_ARTIFACT[options.artifact];
-    super(
-      `${artifactLabel(options.artifact)} ${artifactVerb(
-        options.artifact
-      )} generated for contract ${options.found} but the current contract is ${options.expected}. Your state or phase schemas changed since the artifact was created. Remedy: ${remedy}`
-    );
-    this.name = "StaleContractArtifactError";
-    this.artifact = options.artifact;
-    this.expected = options.expected;
-    this.found = options.found;
-    this.remedy = remedy;
-  }
-};
-function isStaleContractArtifactError(error) {
-  return error instanceof StaleContractArtifactError || typeof error === "object" && error !== null && error.code === "STALE_CONTRACT_ARTIFACT";
-}
-
-export {
-  StaleContractArtifactError,
-  isStaleContractArtifactError
-};

package/dist/agent-verifier/chunk-LM3OZLZG.mjs

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/fs.ts
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
-import path from "path";
-async function ensureDir(dirPath) {
-  await mkdir(dirPath, { recursive: true });
-}
-async function exists(filePath) {
-  try {
-    await stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readTextFile(filePath) {
-  return readFile(filePath, "utf8");
-}
-async function readTextFileIfExists(filePath) {
-  try {
-    return await readFile(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-async function writeTextFile(filePath, content) {
-  await ensureDir(path.dirname(filePath));
-  await writeFile(filePath, content, "utf8");
-}
-async function readJsonFile(filePath) {
-  const data = await readTextFile(filePath);
-  return JSON.parse(data);
-}
-async function writeJsonFile(filePath, data) {
-  await writeTextFile(filePath, `${JSON.stringify(data, null, 2)}
-`);
-}
-
-export {
-  ensureDir,
-  exists,
-  readTextFile,
-  readTextFileIfExists,
-  writeTextFile,
-  readJsonFile,
-  writeJsonFile
-};

package/dist/agent-verifier/chunk-MINCYHXN.mjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/atomic-file.ts
-import { constants as fsConstants, promises as fs } from "fs";
-import path from "path";
-import crypto from "crypto";
-async function atomicWriteFile(targetPath, contents, options = {}) {
-  if (contents.length === 0) {
-    throw new Error(
-      `Refusing to atomicWriteFile an empty payload to ${targetPath}`
-    );
-  }
-  const mode = options.mode ?? 384;
-  const shouldFsync = options.fsync ?? true;
-  const dir = path.dirname(targetPath);
-  await fs.mkdir(dir, { recursive: true });
-  const suffix = crypto.randomBytes(6).toString("hex");
-  const tmpPath = `${targetPath}.tmp-${process.pid}-${suffix}`;
-  const fh = await fs.open(
-    tmpPath,
-    fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL,
-    mode
-  );
-  try {
-    await fh.writeFile(contents, "utf8");
-    try {
-      await fh.chmod(mode);
-    } catch {
-    }
-    if (shouldFsync) {
-      try {
-        await fh.sync();
-      } catch {
-      }
-    }
-  } finally {
-    await fh.close();
-  }
-  try {
-    await fs.rename(tmpPath, targetPath);
-  } catch (err) {
-    await fs.unlink(tmpPath).catch(() => void 0);
-    throw err;
-  }
-}
-async function withFileLock(lockPath, fn, options = {}) {
-  const retries = options.retries ?? 100;
-  const minDelayMs = options.minDelayMs ?? 20;
-  const maxDelayMs = options.maxDelayMs ?? 200;
-  const staleMs = options.staleMs ?? 3e4;
-  await fs.mkdir(path.dirname(lockPath), { recursive: true });
-  let attempt = 0;
-  let acquired = false;
-  while (!acquired) {
-    try {
-      const fh = await fs.open(
-        lockPath,
-        fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL,
-        384
-      );
-      await fh.writeFile(`${process.pid}
-`, "utf8");
-      await fh.close();
-      acquired = true;
-      break;
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST") {
-        throw err;
-      }
-    }
-    let stat = null;
-    try {
-      stat = await fs.stat(lockPath);
-    } catch {
-      continue;
-    }
-    if (stat !== null) {
-      const ageMs = Date.now() - stat.mtimeMs;
-      if (ageMs > staleMs) {
-        await fs.unlink(lockPath).catch(() => void 0);
-        continue;
-      }
-    }
-    attempt += 1;
-    if (attempt >= retries) {
-      throw new Error(
-        `Timed out acquiring file lock at ${lockPath} after ${retries} attempts.`
-      );
-    }
-    const jitter = Math.floor(
-      Math.random() * Math.max(1, maxDelayMs - minDelayMs)
-    );
-    await new Promise((resolve) => setTimeout(resolve, minDelayMs + jitter));
-  }
-  try {
-    return await fn();
-  } finally {
-    await fs.unlink(lockPath).catch(() => void 0);
-  }
-}
-
-export {
-  atomicWriteFile,
-  withFileLock
-};

package/dist/agent-verifier/chunk-MRCUP5SW.mjs

@@ -1,128 +0,0 @@
-#!/usr/bin/env node
-
-// src/services/project/project-state.ts
-var LOCAL_MAINTAINER_SDK_PACKAGE_NAMES = [
-  "@dreamboard-games/api-client",
-  "@dreamboard-games/sdk"
-];
-function getProjectAuthoringState(projectConfig) {
-  return projectConfig.authoring ?? {};
-}
-function getProjectPendingAuthoringSync(projectConfig) {
-  return getProjectAuthoringState(projectConfig).pendingSync;
-}
-function getProjectCompileState(projectConfig) {
-  return projectConfig.compile ?? {};
-}
-function getProjectLocalMaintainerRegistry(projectConfig) {
-  return projectConfig.localMaintainerRegistry;
-}
-function updateProjectAuthoringState(projectConfig, authoring) {
-  return {
-    ...projectConfig,
-    authoring: {
-      ...getProjectAuthoringState(projectConfig),
-      ...authoring
-    }
-  };
-}
-function setProjectPendingAuthoringSync(projectConfig, pendingSync) {
-  return updateProjectAuthoringState(projectConfig, {
-    pendingSync
-  });
-}
-function clearProjectPendingAuthoringSync(projectConfig) {
-  const authoring = getProjectAuthoringState(projectConfig);
-  if (!authoring.pendingSync) {
-    return projectConfig;
-  }
-  const { pendingSync: _pendingSync, ...rest } = authoring;
-  return {
-    ...projectConfig,
-    authoring: rest
-  };
-}
-function finalizeProjectPendingAuthoringSync(projectConfig) {
-  const authoring = getProjectAuthoringState(projectConfig);
-  const pendingSync = authoring.pendingSync;
-  if (!pendingSync) {
-    return projectConfig;
-  }
-  return updateProjectAuthoringState(
-    clearProjectPendingAuthoringSync(projectConfig),
-    {
-      authoringStateId: pendingSync.phase === "authoring_state_created" ? pendingSync.authoringStateId : authoring.authoringStateId,
-      revisionDigest: pendingSync.revisionDigest ?? authoring.revisionDigest,
-      sourceRevisionId: pendingSync.sourceRevisionId,
-      sourceTreeHash: pendingSync.sourceTreeHash,
-      manifestId: pendingSync.manifestId,
-      manifestContentHash: pendingSync.manifestContentHash,
-      localManifestContentHash: pendingSync.localManifestContentHash,
-      ruleId: pendingSync.ruleId
-    }
-  );
-}
-function updateProjectCompileState(projectConfig, compile) {
-  return {
-    ...projectConfig,
-    compile: {
-      ...getProjectCompileState(projectConfig),
-      ...compile
-    }
-  };
-}
-function setLatestCompileAttempt(projectConfig, attempt) {
-  return updateProjectCompileState(projectConfig, {
-    ...getProjectCompileState(projectConfig),
-    latestAttempt: attempt,
-    latestSuccessful: attempt.status === "successful" && attempt.resultId ? {
-      resultId: attempt.resultId,
-      authoringStateId: attempt.authoringStateId,
-      revisionDigest: attempt.revisionDigest
-    } : getProjectCompileState(projectConfig).latestSuccessful
-  });
-}
-function clearProjectCompileState(projectConfig) {
-  return {
-    ...projectConfig,
-    compile: {}
-  };
-}
-function updateProjectLocalMaintainerRegistry(projectConfig, localMaintainerRegistry) {
-  return {
-    ...projectConfig,
-    localMaintainerRegistry: sanitizeProjectLocalMaintainerRegistry(
-      localMaintainerRegistry
-    )
-  };
-}
-function sanitizeProjectLocalMaintainerRegistry(localMaintainerRegistry) {
-  if (!localMaintainerRegistry) return void 0;
-  const packages = {};
-  for (const packageName of LOCAL_MAINTAINER_SDK_PACKAGE_NAMES) {
-    const version = localMaintainerRegistry.packages[packageName];
-    if (version) {
-      packages[packageName] = version;
-    }
-  }
-  return {
-    ...localMaintainerRegistry,
-    packages
-  };
-}
-
-export {
-  getProjectAuthoringState,
-  getProjectPendingAuthoringSync,
-  getProjectCompileState,
-  getProjectLocalMaintainerRegistry,
-  updateProjectAuthoringState,
-  setProjectPendingAuthoringSync,
-  clearProjectPendingAuthoringSync,
-  finalizeProjectPendingAuthoringSync,
-  updateProjectCompileState,
-  setLatestCompileAttempt,
-  clearProjectCompileState,
-  updateProjectLocalMaintainerRegistry,
-  sanitizeProjectLocalMaintainerRegistry
-};

package/dist/agent-verifier/chunk-PM3SVG6R.mjs

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import {
-  ensureProjectSdk,
-  loadRemoteProjectIdentity
-} from "./chunk-EOQIV6PS.mjs";
-import {
-  updateProjectState
-} from "./chunk-2NZNKIND.mjs";
-
-// src/services/project/remote-project.ts
-async function resolveRemoteProject(options) {
-  const identity = await loadRemoteProjectIdentity();
-  const project = await ensureProjectSdk({
-    projectId: options.projectConfig.projectId,
-    slug: options.projectConfig.slug,
-    updateAlias: options.updateAlias
-  });
-  const nextProjectConfig = {
-    ...options.projectConfig,
-    slug: project.slug,
-    deploymentId: identity.deploymentId,
-    ownerScopeId: identity.ownerScopeId,
-    bindingKey: identity.bindingKey,
-    remoteHeadDigest: project.head?.revisionDigest,
-    apiBaseUrl: options.config.apiBaseUrl,
-    webBaseUrl: options.config.webBaseUrl
-  };
-  await updateProjectState(options.projectRoot, nextProjectConfig);
-  return {
-    identity,
-    project,
-    projectConfig: nextProjectConfig
-  };
-}
-
-export {
-  resolveRemoteProject
-};

package/dist/agent-verifier/chunk-RBDDIIPM.mjs

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-
-// src/services/project/framework-dependencies.ts
-var FRAMEWORK_REACT_VERSION = "19.2.6";
-var FRAMEWORK_ZOD_VERSION = "4.4.3";
-var FRAMEWORK_REACT_DEPENDENCIES = {
-  react: FRAMEWORK_REACT_VERSION,
-  "react-dom": FRAMEWORK_REACT_VERSION
-};
-var FRAMEWORK_PNPM_OVERRIDES = {
-  ...FRAMEWORK_REACT_DEPENDENCIES,
-  zod: FRAMEWORK_ZOD_VERSION
-};
-
-export {
-  FRAMEWORK_ZOD_VERSION,
-  FRAMEWORK_REACT_DEPENDENCIES,
-  FRAMEWORK_PNPM_OVERRIDES
-};