@domino-sdk/relay-cli 0.4.0 → 0.6.0

package/cli/capabilities.json

@@ -20,7 +20,7 @@
     {
       "id": "connected-accounts",
       "support": "native",
-      "description": "Operators connect a Discord server and install the managed bot in Console Integrations. Participants sign in with Discord or link its identity. Declare integrations: [discord] and use ctx.discord.member() without a server ID. Captured membership and role reads survive recovery. No messages, writes, or X verification.",
+      "description": "Project-scoped Discord membership, roles, nickname, display name, boosting status and captured message reads. Participants link identity; operators install the bot once. No arbitrary Discord writes or X verification.",
       "entrypoints": [
         "auth.accounts",
         "auth.start",
@@ -43,33 +43,72 @@
         "apps/api/src/identity-integration.ts"
       ]
     },
+    {
+      "id": "observation-quests",
+      "support": "native",
+      "description": "Trusted backend observations and Discord reaction.add, reaction.received and message.create trigger automatic quests. Actor identity is separate from beneficiary membership. Keyed completions and atomic budgets prevent duplicate awards. Multi-action counters and streaks are not implemented.",
+      "entrypoints": [
+        "automatic",
+        "keyed",
+        "budget",
+        "management.observations.submit"
+      ],
+      "reference": "authoring",
+      "evidence": [
+        "tests/observation-quests.test.mjs",
+        "tests/discord-observations.test.mjs"
+      ]
+    },
     {
       "id": "quests",
       "support": "native",
       "description": "Claim, photo, quiz, staff and automatic quests; immutable releases pin attempts and promised rewards.",
-      "entrypoints": ["quests.experience", "quests.observe", "quests.open"],
-      "evidence": ["tests/quest-catalog.test.mjs", "tests/submissions.test.mjs"]
+      "entrypoints": [
+        "quests.experience",
+        "quests.observe",
+        "quests.open"
+      ],
+      "evidence": [
+        "tests/quest-catalog.test.mjs",
+        "tests/submissions.test.mjs"
+      ]
     },
     {
       "id": "points",
       "support": "native",
       "description": "Award points to the participant completing a quest. The server applies completion and rewards; the browser cannot write balances.",
-      "entrypoints": ["points", "decision.accept", "me.observeProgress"],
-      "evidence": ["tests/journey.test.mjs"]
+      "entrypoints": [
+        "points",
+        "decision.accept",
+        "me.observeProgress"
+      ],
+      "evidence": [
+        "tests/journey.test.mjs"
+      ]
     },
     {
       "id": "review",
       "support": "native",
       "description": "Queue a quest attempt for an authorized human reviewer. Review decisions and reward execution remain server-owned.",
-      "entrypoints": ["decision.review"],
-      "evidence": ["tests/photo-review.test.mjs"]
+      "entrypoints": [
+        "decision.review"
+      ],
+      "evidence": [
+        "tests/photo-review.test.mjs"
+      ]
     },
     {
       "id": "milestones",
       "support": "composed",
       "description": "Compose same-participant completion prerequisites with requires: [completed(quest)]. Referral programs support milestones based on distinct qualified friends. Other aggregate thresholds need application logic.",
-      "entrypoints": ["completed", "automatic", "defineQuest"],
-      "evidence": ["tests/availability.test.mjs"]
+      "entrypoints": [
+        "completed",
+        "automatic",
+        "defineQuest"
+      ],
+      "evidence": [
+        "tests/availability.test.mjs"
+      ]
     },
     {
       "id": "referrals",
@@ -83,15 +122,24 @@
         "referrals.history"
       ],
       "reference": "referrals",
-      "evidence": ["tests/referrals.test.mjs", "packages/sdk/src/referrals.ts"]
+      "evidence": [
+        "tests/referrals.test.mjs",
+        "packages/sdk/src/referrals.ts"
+      ]
     },
     {
       "id": "cross-participant-rewards",
       "support": "native",
       "description": "Referral programs can reward inviter and invitee independently and award a selective percentage of eligible points to the inviter. Bonuses accumulate fractions and support limits, suspension and correction recovery. Arbitrary participant-to-participant transfers and multi-level commissions are not supported.",
-      "entrypoints": ["defineReferral", "referrals.summary"],
+      "entrypoints": [
+        "defineReferral",
+        "referrals.summary"
+      ],
       "reference": "referrals",
-      "evidence": ["tests/referrals.test.mjs", "apps/api/src/referrals.ts"]
+      "evidence": [
+        "tests/referrals.test.mjs",
+        "apps/api/src/referrals.ts"
+      ]
     },
     {
       "id": "rankings",
@@ -111,8 +159,44 @@
       "id": "wallet-verification",
       "support": "native",
       "description": "Connect a wallet and verify supported Solana balances. This reads a real network; it does not send assets or execute payouts.",
-      "entrypoints": ["wallet.connection", "wallet.challenge", "wallet.verify"],
-      "evidence": ["tests/wallet.test.mjs"]
+      "entrypoints": [
+        "wallet.connection",
+        "wallet.challenge",
+        "wallet.verify"
+      ],
+      "evidence": [
+        "tests/wallet.test.mjs"
+      ]
+    },
+    {
+      "id": "resource-settings",
+      "support": "native",
+      "description": "Reusable Console resource and date/time fields. Discord channels resolve from the connected project integration; backend publication validates access. Empty resource settings keep code-authored quests paused.",
+      "entrypoints": [
+        "settings.resource",
+        "settings.datetime",
+        "discord.channels",
+        "discord.roles"
+      ],
+      "reference": "authoring",
+      "evidence": [
+        "tests/resource-settings.test.mjs"
+      ]
+    },
+    {
+      "id": "discord-role-rewards",
+      "support": "native",
+      "description": "Quest-declared Discord role rewards commit durable delivery requests with completion, retry independently, and remain bound to the original account/server. Role selectors validate assignability. Referral reward lists do not accept integration rewards.",
+      "entrypoints": [
+        "discordRole",
+        "me.rewardDeliveries",
+        "management.rewardDeliveries"
+      ],
+      "reference": "authoring",
+      "evidence": [
+        "tests/discord-role-delivery.test.mjs",
+        "tests/discord-expansion.test.mjs"
+      ]
     }
   ]
 }

package/cli/commands/agents.mjs

@@ -2,6 +2,7 @@ import { Option } from "commander";
 import { dirname } from "node:path";
 import { action } from "../runtime.mjs";
 import { installAgentSkills } from "../agents.mjs";
+import { canPrompt, promptSelect } from "../prompts.mjs";
 import { diagnose } from "../doctor.mjs";
 
 export function registerAgentCommands(program) {
@@ -17,18 +18,29 @@ export function registerAgentCommands(program) {
       "Project root (defaults to the linked project or current directory)",
     )
     .addOption(
-      new Option("--agent <name>", "Agent to configure")
-        .choices(["codex", "claude", "both"])
-        .default("both"),
+      new Option("--agent <name>", "Agent to configure").choices([
+        "codex",
+        "claude",
+        "both",
+      ]),
     )
     .action(
-      action(({ project, options }) =>
-        installAgentSkills(
+      action(async ({ project, options }) => {
+        const agent =
+          options.agent ??
+          (canPrompt(options)
+            ? await promptSelect("Choose your coding agent", [
+                { label: "Codex", value: "codex" },
+                { label: "Claude", value: "claude" },
+                { label: "Both", value: "both" },
+              ])
+            : "both");
+        return installAgentSkills(
           options.directory ??
             (project ? dirname(project.path) : process.cwd()),
-          options.agent,
-        ),
-      ),
+          agent,
+        );
+      }),
     );
 
   program

package/cli/commands/discovery.mjs

@@ -1,11 +1,18 @@
 import { readFile } from "node:fs/promises";
 import { action } from "../runtime.mjs";
 
-const references = ["authoring", "participant-api", "referrals", "troubleshooting"];
+const references = [
+  "authoring",
+  "participant-api",
+  "referrals",
+  "troubleshooting",
+];
 export function registerDiscoveryCommands(program) {
   program
     .command("capabilities")
-    .description("Discover supported Domino features and their limitations")
+    .description(
+      "Read this CLI release's bundled capability catalog (not a server probe)",
+    )
     .argument("[id]", "Capability identifier")
     .action(
       action(async (_, id) => {
@@ -15,13 +22,25 @@ export function registerDiscoveryCommands(program) {
             "utf8",
           ),
         );
-        if (!id) return catalog;
+        const { version } = JSON.parse(
+          await readFile(
+            new URL("../../package.json", import.meta.url),
+            "utf8",
+          ),
+        );
+        const provenance = {
+          kind: "bundled-catalog",
+          cliVersion: version,
+          serverVerified: false,
+          note: "Describes this CLI release. Scope flags do not make it project-specific. Verify the deployed contract before treating missing or conflicting entries as unsupported.",
+        };
+        if (!id) return { ...catalog, provenance };
         const capability = catalog.capabilities.find((item) => item.id === id);
         if (!capability)
           throw new Error(
             `Unknown capability. Choose: ${catalog.capabilities.map((item) => item.id).join(", ")}`,
           );
-        return capability;
+        return { ...capability, provenance };
       }),
     );
   program

package/cli/commands/hosting.mjs

@@ -4,6 +4,8 @@ import { dirname, resolve } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { action } from "../runtime.mjs";
+import { canPrompt, promptText, promptSelect } from "../prompts.mjs";
+import { selectProject } from "../select-project.mjs";
 import { request } from "../connection.mjs";
 import { checkout, requireNewDirectory } from "../git.mjs";
 import { dev } from "../dev.mjs";
@@ -69,20 +71,54 @@ export function registerHostingCommands(program) {
   program
     .command("create")
     .description("Create a hosted campaign repository and check it out locally")
-    .argument("<name>", "Project identifier")
+    .argument("[name]", "Project identifier (prompted if omitted)")
     .option("--directory <path>", "Local directory (defaults to project name)")
     .action(
       action(async ({ connection, options }, name) => {
-        if (!/^[a-zA-Z0-9_-]+$/.test(name))
-          throw new Error(
-            "Use letters, numbers, underscores, or hyphens for the project name.",
-          );
-        const directory = resolve(options.directory ?? name);
+        const interactive = canPrompt(options);
+        const validateName = (value) =>
+          /^[a-zA-Z0-9_-]+$/.test(value)
+            ? undefined
+            : "Use letters, numbers, underscores, or hyphens for the project name.";
+        if (!name && interactive)
+          name = await promptText("Project name", { validate: validateName });
+        if (!name)
+          throw new Error("Provide a project name: domino create NAME.");
+        const nameError = validateName(name);
+        if (nameError) throw new Error(nameError);
+        const destination =
+          options.directory ??
+          (interactive
+            ? await promptText("Destination directory", {
+                defaultValue: name,
+                validate: async (value) => {
+                  try {
+                    await requireNewDirectory(resolve(value));
+                  } catch (error) {
+                    return error.message;
+                  }
+                },
+              })
+            : name);
+        const directory = resolve(destination);
         await requireNewDirectory(directory);
         const access = await request(connection, "/access");
-        const organization = connection.organization || access.organization;
+        let organization = connection.organization || access.organization;
+        if (!organization && interactive) {
+          const organizations = [
+            ...new Set(
+              access.projects.map((item) => item.organization).filter(Boolean),
+            ),
+          ];
+          organization = organizations.length
+            ? await promptSelect(
+                "Choose an organization",
+                organizations.map((id) => ({ label: id, value: id })),
+              )
+            : await promptText("Organization ID");
+        }
         if (!organization)
-          throw new Error("Select an organization with --organization.");
+          throw new Error("Select an organization with --organization ID.");
         const scoped = {
           ...connection,
           organization,
@@ -101,13 +137,31 @@ export function registerHostingCommands(program) {
     .description(
       "Recover or clone a hosted campaign with Domino Git authentication",
     )
-    .argument("<project>")
+    .argument(
+      "[project]",
+      "Project identifier (choose interactively if omitted)",
+    )
     .option("--directory <path>", "Local directory (defaults to project name)")
     .action(
       action(async ({ connection, options }, project) => {
-        const scoped = { ...connection, project, environment: "test" };
+        const scoped = {
+          ...connection,
+          project: project ?? connection.project,
+          environment: "test",
+        };
+        if (!scoped.project) {
+          const access = await request(scoped, "/access");
+          const selected = await selectProject(access, scoped, options);
+          scoped.project = selected.project;
+          scoped.organization =
+            scoped.organization ?? selected.organization ?? access.organization;
+        }
         const repository = await request(scoped, "/repository");
-        return checkout(scoped, repository, options.directory ?? project);
+        return checkout(
+          scoped,
+          repository,
+          options.directory ?? scoped.project,
+        );
       }),
     );
 }

package/cli/commands/inspect.mjs

@@ -16,7 +16,11 @@ export function registerInspectCommands(program) {
   program
     .command("status")
     .description("Show the project overview")
-    .action(action(({ connection }) => request(connection, "/overview")));
+    .action(
+      action(({ connection }) => request(connection, "/overview"), {
+        projectScope: true,
+      }),
+    );
 
   for (const [name, description] of [
     ["quests", "List current quests"],
@@ -34,14 +38,17 @@ export function registerInspectCommands(program) {
       .option("--filter <value>", "Filter the collection")
       .option("--q <text>", "Search the collection")
       .action(
-        action(({ connection, options }) => {
-          const query = new URLSearchParams();
-          for (const key of ["limit", "offset", "filter", "q"]) {
-            if (options[key] !== undefined)
-              query.set(key, String(options[key]));
-          }
-          return request(connection, `/${name}?${query}`);
-        }),
+        action(
+          ({ connection, options }) => {
+            const query = new URLSearchParams();
+            for (const key of ["limit", "offset", "filter", "q"]) {
+              if (options[key] !== undefined)
+                query.set(key, String(options[key]));
+            }
+            return request(connection, `/${name}?${query}`);
+          },
+          { projectScope: true },
+        ),
       );
   }
 }

package/cli/commands/project.mjs

@@ -1,5 +1,8 @@
-import { writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
 import { action } from "../runtime.mjs";
+import { confirmAction } from "../prompts.mjs";
+import { selectProject } from "../select-project.mjs";
 import { request } from "../connection.mjs";
 import { initialize, bundleProject } from "../project.mjs";
 
@@ -63,7 +66,17 @@ async function build({ project, connection, options }, deploy) {
     throw new Error(
       "Live publication requires Console approval. Run deploy --dry-run --out deployment.json, then import the project deployment in Console.",
     );
-  if (options.resume) return publish(connection, options.resume);
+  const confirmPublication = (detail) =>
+    confirmAction(
+      options,
+      `Publish to ${connection.organization ?? "current organization"}/${connection.project} in ${connection.environment ?? "test"}.
+API: ${connection.apiUrl}
+${detail}`,
+    );
+  if (options.resume) {
+    await confirmPublication(`Resume deployment ${options.resume}.`);
+    return publish(connection, options.resume);
+  }
   const payload = await bundleProject(project);
   if (deploy) {
     const preview = await request(
@@ -73,9 +86,13 @@ async function build({ project, connection, options }, deploy) {
       payload,
     );
     if (options.preview) return { status: "preview", ...summary(preview) };
+    await confirmPublication(
+      `Deployment ${preview.id}: ${preview.releases.length} quests, ${preview.types.length} types, ${preview.collections.length} collections, ${preview.leaderboards.length} leaderboards, ${preview.referrals.length} referral programs.`,
+    );
     return publish(connection, preview.id);
   }
   if (options.out) {
+    await mkdir(dirname(options.out), { recursive: true });
     await writeFile(options.out, JSON.stringify(payload, null, 2) + "\n");
     return {
       file: options.out,
@@ -102,21 +119,11 @@ export function registerProjectCommands(program) {
     .action(
       action(async ({ connection, options }, directory) => {
         const access = await request(connection, "/access");
-        const selected = connection.project
-          ? access.projects.find((item) => item.project === connection.project)
-          : access.projects.length === 1
-            ? access.projects[0]
-            : null;
-        if (!selected)
-          throw new Error(
-            "Select an accessible project with --project ID. Run domino whoami to list projects; create projects in Console.",
-          );
+        const selected = await selectProject(access, connection, options);
         const environment = connection.environment ?? "test";
-        if (!selected.environments.includes(environment))
-          throw new Error(`No access to ${environment} for this project.`);
         return initialize(directory, {
           ...connection,
-          organization: access.organization,
+          organization: selected.organization ?? access.organization,
           project: selected.project,
           environment,
           quests: (options.entry ?? []).map((entry) => ({
@@ -144,6 +151,7 @@ export function registerProjectCommands(program) {
     .description(
       "Atomically deploy quests, reusable types, and collection slots, preserving Console-owned settings and placement",
     )
+    .option("--yes", "Skip the terminal publication confirmation")
     .option(
       "--dry-run",
       "Build locally only; does not preview Relay custom values",

package/cli/commands/staging.mjs

@@ -2,6 +2,8 @@ import { dirname } from "node:path";
 import { randomUUID } from "node:crypto";
 import { action } from "../runtime.mjs";
 import { request } from "../connection.mjs";
+import { canPrompt, promptSelect, confirmAction } from "../prompts.mjs";
+import { projectConnection } from "../select-project.mjs";
 import { runGit } from "../git.mjs";
 
 export function registerStagingCommands(program) {
@@ -15,21 +17,25 @@ export function registerStagingCommands(program) {
       "--request-id <uuid>",
       "Resume a previously submitted build request",
     )
+    .option("--yes", "Skip the terminal confirmation")
     .option("--no-wait", "Return the build ID without waiting")
     .action(
       action(async ({ connection, project, options }) => {
         if (!project)
           throw new Error("Run stage inside a hosted campaign checkout.");
-        if (project.config.app?.kind !== "static")
+        if (!project.config.app)
           throw new Error(
-            "Cloud staging currently supports static campaign checkouts with app.kind=static in relay.json. This project is not configured for cloud staging. SSR Worker apps use the Cloudflare Worker deployment workflow.",
+            "Configure app.kind as static or worker in relay.json before staging.",
           );
         const scoped = { ...connection, environment: "test" };
         const preflight = await request(scoped, "/preflight");
         if (preflight.staging !== "configured")
           throw new Error(
             preflight.checks
-              .filter((check) => check.status === "error")
+              .filter(
+                (check) =>
+                  check.id !== "hosted-test-auth" && check.status === "error",
+              )
               .map((check) => check.message)
               .join("\n"),
           );
@@ -45,6 +51,12 @@ export function registerStagingCommands(program) {
           options.commit ?? (await runGit(["rev-parse", "HEAD"], { cwd }));
         if (!/^[a-f0-9]{40}$/.test(commit))
           throw new Error("Use a full 40-character commit SHA.");
+        await confirmAction(
+          options,
+          `Stage commit ${commit} for ${scoped.organization ?? "current organization"}/${scoped.project} in test.
+API: ${scoped.apiUrl}
+This builds the pushed commit and updates its staging preview.`,
+        );
         const requestId = options.requestId ?? randomUUID();
         process.stderr.write(`Build request ${requestId}\n`);
         let build;
@@ -81,18 +93,41 @@ export function registerStagingCommands(program) {
     .command("builds")
     .description("List recent cloud builds for this campaign")
     .action(
-      action(({ connection }) =>
-        request({ ...connection, environment: "test" }, "/builds"),
-      ),
+      action(({ connection }) => request(connection, "/builds"), {
+        projectScope: true,
+        environment: "test",
+      }),
     );
   program
     .command("logs")
     .description("Read retained cloud build logs")
-    .argument("<id>", "Build ID")
+    .argument("[id]", "Build ID (choose a recent build if omitted)")
     .action(
-      action(({ connection }, id) => {
-        if (!/^[a-f0-9-]{36}$/.test(id))
+      action(async ({ connection, options }, id) => {
+        if (!id && !canPrompt(options))
+          throw new Error(
+            "Provide a build ID: domino logs ID. Run domino builds to list recent builds.",
+          );
+        if (id && !/^[a-f0-9-]{36}$/.test(id))
           throw new Error("Expected a build UUID.");
+        connection = await projectConnection(
+          { ...connection, environment: "test" },
+          options,
+        );
+        if (!id) {
+          const builds = await request(connection, "/builds");
+          if (!builds.length)
+            throw new Error(
+              "No builds yet. Push a commit and run domino stage first.",
+            );
+          id = await promptSelect(
+            "Choose a build",
+            builds.map((build) => ({
+              label: `${build.phase} • ${new Date(build.createdAt).toISOString()} • ${build.commit.slice(0, 8)} • ${build.id}${build.current ? " • current" : ""}`,
+              value: build.id,
+            })),
+          );
+        }
         return request(
           { ...connection, environment: "test" },
           `/builds/${id}/logs`,

package/cli/connected-dev.mjs

@@ -22,7 +22,7 @@ export async function connectedDev(project, connection, options) {
   const preflight = await request(connection, "/preflight");
   if (preflight.development?.status !== "configured")
     throw new Error(
-      "Hosted development is not configured. Run domino doctor --remote --json; a Domino operator must enable previews and test sign-in.",
+      "Hosted development is not configured. Run domino doctor --remote --json; a Domino operator must enable preview hosting.",
     );
   const root = dirname(project.path);
   const connector = await previewConnector(options.cloudflared);
@@ -126,6 +126,7 @@ export async function connectedDev(project, connection, options) {
     session = await request(connection, "/development/session", "POST", {
       ...lease,
       port,
+      routing: project.config.app.routing,
     });
     const sync = developmentSync(connection, project.path);
     await sync();
@@ -143,6 +144,7 @@ export async function connectedDev(project, connection, options) {
     start("pnpm", ["run", project.config.app.devScript], {
       DOMINO_APP_PORT: String(port),
       DOMINO_PREVIEW_ORIGIN: session.url,
+      DOMINO_PARTICIPANT_API: connection.apiUrl,
     });
     let appReady = false;
     for (let attempt = 0; attempt < 150 && !stopping; attempt++) {
@@ -190,7 +192,7 @@ export async function connectedDev(project, connection, options) {
         )
       );
     process.stderr.write(
-      `Preview: ${session.url}\nUses this project's hosted test data and real sign-in. Keep this terminal running. Use domino stage for a preview that stays online.\n`,
+      `Preview: ${session.url}\nKeep this terminal running. Use domino stage for a preview that stays online.\n`,
     );
     let renewed = Date.now();
     while (!stopping) {

package/cli/dev.mjs

@@ -113,7 +113,7 @@ export async function dev(project, options) {
     const child = spawn(command, args, {
       cwd: root,
       env: { ...process.env, ...extraEnv },
-      stdio: "inherit",
+      stdio: ["inherit", 2, 2],
       detached: process.platform !== "win32",
     });
     children.push(child);