@dreamboard-games/cli 0.1.30-alpha.0

package/README.md

@@ -0,0 +1,50 @@
+# Dreamboard CLI
+
+Dreamboard CLI supports three main workflows:
+
+- Authoring: `dreamboard sync`, `dreamboard compile`, `dreamboard pull`
+- Interactive verification: `dreamboard dev`
+- Scripted verification: `dreamboard test generate`, `dreamboard test run`
+
+## Install
+
+```bash
+npm install -g dreamboard
+dreamboard login
+```
+
+## Create a game
+
+```bash
+dreamboard new my-game --description "A short game description"
+cd my-game
+```
+
+## Iterate
+
+```bash
+dreamboard sync
+dreamboard compile
+dreamboard dev
+```
+
+`dreamboard dev` starts the local iframe host for the current project while gameplay continues on the backend.
+
+## Test
+
+```bash
+dreamboard test generate
+dreamboard test run
+dreamboard test run --scenario test/scenarios/example.scenario.ts
+```
+
+Scenario assertions must use the projection-only API from `test/testing-types.ts`:
+
+- `players()`
+- `state()`
+- `view(playerId)`
+- `expect`
+
+## Scaffold ownership
+
+Framework-owned static scaffold files are restored by `dreamboard sync`. Generated projects no longer expose wire-format message typings.

package/dist/agent-verifier/agent-workspace-verifier.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import {
+  assertCompilerPortableDependencies,
+  consola,
+  resolveProjectContext
+} from "./chunk-RJBLBYHX.mjs";
+import "./chunk-HJFQDSTU.mjs";
+import "./chunk-2NZNKIND.mjs";
+import "./chunk-2E5P5NWG.mjs";
+import "./chunk-MINCYHXN.mjs";
+import "./chunk-LM3OZLZG.mjs";
+import "./chunk-SHUMAVAP.mjs";
+import "./chunk-XYDL7GY6.mjs";
+
+// src/agent-workspace-verifier.ts
+import { readFile } from "fs/promises";
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "--help" || command === "help") {
+    printHelp();
+    return;
+  }
+  if (command === "materialize-prepared-workspace") {
+    if (args.includes("--help")) {
+      printHelp();
+      return;
+    }
+    await materializePreparedWorkspace(args);
+    return;
+  }
+  await verifyAgentWorkspace(command ?? "verify", args);
+}
+function printHelp() {
+  console.log(`Dreamboard agent workspace verifier
+
+Usage:
+  agent-workspace-verifier materialize-prepared-workspace --input <path>
+  agent-workspace-verifier preflight [--env local|dev|prod]
+  agent-workspace-verifier verify [--env local|dev|prod]
+  agent-workspace-verifier fin [--env local|dev|prod]
+`);
+}
+async function materializePreparedWorkspace(args) {
+  const inputPath = readRequiredOption(args, "--input");
+  const input = JSON.parse(await readFile(inputPath, "utf8"));
+  const { materializeWorkspaceProject } = await import("./materialize-workspace-EWGZIVOY.mjs");
+  await materializeWorkspaceProject({
+    ...input,
+    agentManaged: true,
+    workspacePrepared: true,
+    allowCreateGame: false,
+    installDependencies: false
+  });
+  consola.success(`Prepared workspace in ${input.targetDir}`);
+}
+async function verifyAgentWorkspace(rawMode, args) {
+  const requestedMode = parseVerificationMode(rawMode);
+  const parsedFlags = parseConfigArgs(args);
+  const { projectRoot, projectConfig, config } = await resolveProjectContext(parsedFlags);
+  await assertCompilerPortableDependencies({ projectRoot, projectConfig });
+  if (requestedMode === "preflight") {
+    consola.success("Agent workspace preflight passed.");
+    return;
+  }
+  if (process.env.DREAMBOARD_AGENT_FINAL_SYNC_VERIFY === "1") {
+    await runFullBackendConnectedVerification(parsedFlags);
+    return;
+  }
+  if (requestedMode === "cloud-local" || requestedMode === "verify" || requestedMode === "fin") {
+    await runCloudLocalVerification(projectRoot, projectConfig, config);
+    return;
+  }
+  throw new Error(
+    "Agent workspaces now run cloud-local verification directly. Use `fin` only through the generated wrapper."
+  );
+}
+async function runFullBackendConnectedVerification(parsedFlags) {
+  const [{ default: cmdSync }, { default: cmdCompile }, { default: cmdTest }] = await Promise.all([
+    import("./sync-LOQAH4RC.mjs"),
+    import("./compile-WNCQQVOF.mjs"),
+    import("./test-YOJERVHN.mjs")
+  ]);
+  await runCommandDefinition(cmdSync, { ...parsedFlags, force: true });
+  await runCommandDefinition(cmdCompile, parsedFlags);
+  await runCommandDefinition(
+    resolveTestSubCommand(cmdTest, "generate"),
+    parsedFlags
+  );
+  await runCommandDefinition(
+    resolveTestSubCommand(cmdTest, "run"),
+    parsedFlags
+  );
+}
+async function runCommandDefinition(command, args) {
+  if (!command.run) {
+    throw new Error("Verifier command is missing a runnable step.");
+  }
+  await command.run({ args, rawArgs: [], cmd: command });
+}
+function resolveTestSubCommand(cmdTest, name) {
+  const subCommands = cmdTest.subCommands;
+  const command = subCommands?.[name];
+  if (!command) {
+    throw new Error(`Verifier command is missing test ${name}.`);
+  }
+  return command;
+}
+function parseVerificationMode(value) {
+  if (value === "preflight" || value === "verify" || value === "fin" || value === "cloud-local") {
+    return value;
+  }
+  throw new Error(
+    `Expected mode to be one of preflight, verify, fin, or cloud-local. Received: ${String(value)}`
+  );
+}
+function parseConfigArgs(args) {
+  const flags = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--env") {
+      const value = args[++index];
+      if (value === "local" || value === "staging" || value === "prod") {
+        flags.env = value;
+        continue;
+      }
+      throw new Error(`Invalid --env value: ${String(value)}`);
+    }
+    if (arg === "--token") {
+      flags.token = args[++index];
+      continue;
+    }
+    if (arg === "--skip-install") {
+      continue;
+    }
+    throw new Error(`Unknown verifier argument: ${arg}`);
+  }
+  return flags;
+}
+async function runCloudLocalVerification(projectRoot, projectConfig, config) {
+  const [
+    { scaffoldStaticWorkspace },
+    { loadManifest },
+    { applyWorkspaceCodegen },
+    { reconcileWorkspaceDependencies },
+    { assertReducerContractPreflight },
+    { getProjectLocalMaintainerRegistry }
+  ] = await Promise.all([
+    import("./static-scaffold-4YEQME5N.mjs"),
+    import("./local-files-MTPLP62S.mjs"),
+    import("./workspace-codegen-JDZJRSDV.mjs"),
+    import("./workspace-dependencies-HZ6VVS4G.mjs"),
+    import("./reducer-contract-preflight-22X7DSZW.mjs"),
+    import("./project-state-7GR6BQTQ.mjs")
+  ]);
+  consola.start("Refreshing static scaffold...");
+  await scaffoldStaticWorkspace(projectRoot, "update", {
+    localMaintainerRegistry: getProjectLocalMaintainerRegistry(projectConfig)
+  });
+  consola.start("Applying workspace codegen...");
+  const manifest = await loadManifest(projectRoot);
+  await applyWorkspaceCodegen({ projectRoot, manifest });
+  consola.start("Reconciling workspace dependencies...");
+  await reconcileWorkspaceDependencies(projectRoot);
+  consola.start("Validating reducer contract...");
+  await assertReducerContractPreflight(projectRoot);
+  const [{ runLocalTypecheck }, { assertReducerBundleSmoke }] = await Promise.all([
+    import("./local-typecheck-QFYYAZOK.mjs"),
+    import("./reducer-bundle-preflight-C73LEXI2.mjs")
+  ]);
+  consola.start("Running local typecheck...");
+  const typecheckResult = await runLocalTypecheck(projectRoot);
+  if (typecheckResult.skipped) {
+    if (typecheckResult.output) consola.warn(typecheckResult.output);
+  } else if (!typecheckResult.success) {
+    if (typecheckResult.output) consola.error(typecheckResult.output);
+    throw new Error(
+      "Local typecheck failed. Fix the diagnostics before syncing."
+    );
+  }
+  consola.start("Smoke-testing reducer bundle...");
+  await assertReducerBundleSmoke({ projectRoot, manifest });
+  const {
+    generateReducerNativeArtifacts,
+    isReducerNativeTestingWorkspace,
+    runReducerNativeScenarios
+  } = await import("./reducer-native-test-harness-GMWBUISX.mjs");
+  if (await isReducerNativeTestingWorkspace(projectRoot)) {
+    const { bases } = await generateReducerNativeArtifacts({
+      projectRoot,
+      gameId: projectConfig.gameId,
+      compiledResultId: projectConfig.compile?.latestSuccessful?.resultId
+    });
+    const summary = await runReducerNativeScenarios({
+      projectRoot,
+      projectConfig,
+      resolvedConfig: config,
+      runner: "reducer",
+      gameId: projectConfig.gameId,
+      compiledResultId: projectConfig.compile?.latestSuccessful?.resultId
+    });
+    if (summary.failed > 0) {
+      const failures = summary.results.filter((result) => !result.success).map(
+        (result) => result.error ? `FAIL ${result.id}: ${result.error}` : `FAIL ${result.id}`
+      );
+      throw new Error(
+        [
+          `Reducer-native verification failed: ${summary.failed} failed, ${summary.passed} passed.`,
+          ...failures
+        ].join("\n")
+      );
+    }
+    consola.success(`Generated ${bases.length} reducer-native base state(s).`);
+  }
+  consola.success("Agent workspace cloud-local verification passed.");
+}
+function readRequiredOption(args, name) {
+  const index = args.indexOf(name);
+  const value = index >= 0 ? args[index + 1] : void 0;
+  if (!value) {
+    throw new Error(`${name} is required.`);
+  }
+  return value;
+}