@domino-sdk/relay-cli 0.5.0 → 0.7.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/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,6 +1,8 @@
 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";
 
@@ -64,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(
@@ -74,6 +86,9 @@ 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) {
@@ -104,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) => ({
@@ -146,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,6 +17,7 @@ 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 }) => {
@@ -29,7 +32,10 @@ export function registerStagingCommands(program) {
         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/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);

package/cli/output.mjs

@@ -0,0 +1,76 @@
+// Keep presentation separate from the result contracts consumed with --json.
+const label = (key) => {
+  const words = key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+const scalar = (value) =>
+  value == null
+    ? "—"
+    : typeof value === "boolean"
+      ? value
+        ? "yes"
+        : "no"
+      : String(value);
+
+export function formatDetails(value, indent = "") {
+  if (value === null || typeof value !== "object")
+    return indent + scalar(value);
+  if (Array.isArray(value)) {
+    if (!value.length) return indent + "None";
+    return value
+      .map((item) => {
+        if (item === null || typeof item !== "object")
+          return `${indent}- ${scalar(item)}`;
+        return formatDetails(item, indent + "  ").replace(
+          indent + "  ",
+          indent + "- ",
+        );
+      })
+      .join("\n");
+  }
+  const entries = Object.entries(value).filter(
+    ([, item]) => item !== undefined,
+  );
+  if (!entries.length) return indent + "None";
+  return entries
+    .map(([key, item]) =>
+      item !== null && typeof item === "object"
+        ? `${indent}${label(key)}:\n${formatDetails(item, indent + "  ")}`
+        : `${indent}${label(key)}: ${scalar(item)}`,
+    )
+    .join("\n");
+}
+
+export function formatResult(command, result, options = {}) {
+  if (options.json || command === "api")
+    return JSON.stringify(result, null, options.json ? undefined : 2);
+  if (command === "logs") return result.logs.trimEnd();
+  if (command === "reference" && result.markdown)
+    return result.markdown.trimEnd();
+  if (command === "whoami") {
+    const identity = formatDetails({
+      actor: result.actor,
+      organization: result.organization,
+    });
+    const projects = result.projects.map(
+      (item) =>
+        `  ${item.name && item.name !== item.project ? `${item.name} (${item.project})` : item.project}  [${item.environments.join(", ")}]`,
+    );
+    return `${identity}\n\nAccessible projects:\n${projects.length ? projects.join("\n") : "  None"}\n\nRun domino checkout to choose a hosted project, or domino init to link this app.`;
+  }
+  if (
+    (command === "build" || (command === "deploy" && options.dryRun)) &&
+    result.releases
+  ) {
+    return formatDetails({
+      result: "Bundle ready",
+      quests: result.releases.length,
+      types: result.types.length,
+      collections: result.collections.length,
+      leaderboards: result.leaderboards.length,
+      referrals: result.referrals.length,
+      next: "Use --out FILE to save the bundle, or --json to print it.",
+    });
+  }
+  return formatDetails(result);
+}