@popoverai/dotrequirements 0.32.1 → 0.34.0

package/dist/cli.js

@@ -2,10 +2,11 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { acceptanceTestCommand } from "./commands/acceptance-test.js";
 import { aiSetupCommand } from "./commands/ai-setup.js";
 import { pullAlias, pushAlias } from "./commands/aliases.js";
+import { registerBoard } from "./commands/board/index.js";
 import { registerCodebaseToSpec } from "./commands/codebase-to-spec/index.js";
 import { createRequirementDocumentCommand } from "./commands/create-requirement-document.js";
 import { diffCommand } from "./commands/diff.js";
@@ -16,17 +17,22 @@ import { initCommand } from "./commands/init.js";
 import { linkCommand } from "./commands/link.js";
 import { listCommand } from "./commands/list.js";
 import { mcpCommand } from "./commands/mcp.js";
+import { registerMockup } from "./commands/mockup/index.js";
 import { prepareCommand } from "./commands/prepare.js";
 import { reportCommand } from "./commands/report.js";
 import { requirementsForCommand } from "./commands/requirements-for.js";
 import { reviewTestCommand } from "./commands/review-test.js";
+import { registerScores } from "./commands/scores/index.js";
 import { searchCommand } from "./commands/search.js";
+import { registerSolution } from "./commands/solution/index.js";
 import { styleCheckCommand } from "./commands/style-check.js";
 import { syncCliAction } from "./commands/sync.js";
 import { testsForCommand } from "./commands/tests-for.js";
 import { validateCommand } from "./commands/validate.js";
+import { commandErrorMessage } from "./utils/command-error.js";
 import { loadEnvFile } from "./utils/env.js";
 import { setPreferEnvCredentials } from "./utils/project-settings.js";
+import { enableVersionMessages, formatVersionMessages, markVersionMessagesShown, versionMessages, } from "./version-messages.js";
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -34,6 +40,20 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 const VERSION = packageJson.version;
 // Load environment variables from .env.local if it exists
 loadEnvFile();
+// CLI-MSG-1: a run that reaches the cloud hears what it has to say to this
+// version.
+enableVersionMessages();
+/**
+ * The cloud's messages for this version, after the command's own output. On
+ * stderr, so a command's piped output stays clean.
+ */
+async function printVersionMessages() {
+    const messages = await versionMessages();
+    if (messages.length > 0) {
+        console.error(`${formatVersionMessages(messages)}\n`);
+    }
+    markVersionMessagesShown();
+}
 /**
  * Wrap command handlers to catch errors and display them cleanly
  * without showing stack traces to users
@@ -44,14 +64,11 @@ function wrapCommand(fn) {
             await fn(...args);
         }
         catch (error) {
-            if (error instanceof Error) {
-                console.error(`\nError: ${error.message}\n`);
-            }
-            else {
-                console.error(`\nError: ${String(error)}\n`);
-            }
+            console.error(`\nError: ${commandErrorMessage(error)}\n`);
+            await printVersionMessages();
             process.exit(1);
         }
+        await printVersionMessages();
     };
 }
 const program = new Command();
@@ -102,6 +119,10 @@ program
     .option("-s, --share <token>", "Read-only share token (no setup required)")
     .option("-p, --project <id>", "Override the project slug")
     .option("-y, --yes", "Skip the deletion confirmation prompt")
+    // BRANCH-8: merging a solution's branch into main. Kept out of --help, as
+    // the solution verbs are, until the solution flow is offered.
+    .addOption(new Option("--branch-contributes <solution-id>", "Merge the solution's branch into main: its additions only").hideHelp())
+    .addOption(new Option("--branch-wins <solution-id>", "Merge the solution's branch into main: the branch overwrites what differs").hideHelp())
     .action(wrapCommand(syncCliAction));
 // Deprecated aliases into `sync`, kept for commands already in the wild
 // (SYNC-ALIAS-1). Each prints a deprecation notice naming its new spelling.
@@ -212,5 +233,9 @@ program
     .description("Print the greenfield interview protocol — for working out what something new should do before writing its spec")
     .action(wrapCommand(greenfieldDiscoveryCommand));
 registerCodebaseToSpec(program);
+registerSolution(program);
+registerMockup(program);
+registerBoard(program);
+registerScores(program);
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/cloud.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The one way into the dotrequirements cloud. Every place the CLI reaches the
+ * cloud asks here for the address, so the first use in a run is visible — the
+ * version-message check (CLI-MSG-1) starts there.
+ */
+/** The web app, home of the hosted AI endpoints and publishing. */
+export declare const DEFAULT_API_BASE_URL = "https://app.dotrequirements.io";
+/**
+ * The Convex backend's address, for a ConvexHttpClient or its HTTP API:
+ * production, unless DOTREQ_CONVEX_URL points somewhere else, such as a dev
+ * or preview deployment.
+ */
+export declare function convexUrl(): string;
+/** The web app's address; `DOTREQUIREMENTS_API_URL` overrides it. */
+export declare function webApiUrl(): string;
+/** Run `callback` the first time this process reaches the cloud. */
+export declare function whenCloudFirstUsed(callback: () => void): void;
+//# sourceMappingURL=cloud.d.ts.map

package/dist/cloud.js

@@ -0,0 +1,38 @@
+/**
+ * The one way into the dotrequirements cloud. Every place the CLI reaches the
+ * cloud asks here for the address, so the first use in a run is visible — the
+ * version-message check (CLI-MSG-1) starts there.
+ */
+/** The Convex backend every user's CLI talks to. */
+const CONVEX_URL = "https://data.dotrequirements.io";
+/** The web app, home of the hosted AI endpoints and publishing. */
+export const DEFAULT_API_BASE_URL = "https://app.dotrequirements.io";
+let onFirstUse = null;
+let used = false;
+function noteUse() {
+    if (used)
+        return;
+    used = true;
+    onFirstUse?.();
+}
+/**
+ * The Convex backend's address, for a ConvexHttpClient or its HTTP API:
+ * production, unless DOTREQ_CONVEX_URL points somewhere else, such as a dev
+ * or preview deployment.
+ */
+export function convexUrl() {
+    noteUse();
+    return process.env.DOTREQ_CONVEX_URL?.trim() || CONVEX_URL;
+}
+/** The web app's address; `DOTREQUIREMENTS_API_URL` overrides it. */
+export function webApiUrl() {
+    noteUse();
+    return process.env.DOTREQUIREMENTS_API_URL ?? DEFAULT_API_BASE_URL;
+}
+/** Run `callback` the first time this process reaches the cloud. */
+export function whenCloudFirstUsed(callback) {
+    onFirstUse = callback;
+    if (used)
+        callback();
+}
+//# sourceMappingURL=cloud.js.map

package/dist/commands/board/index.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+export declare function guideCommand(): Promise<void>;
+export declare function createCommand(options: {
+    title: string;
+    description?: string;
+    file: string;
+}): Promise<void>;
+export declare function updateCommand(boardId: string, options: {
+    file: string;
+}): Promise<void>;
+export declare function showCommand(boardId: string): Promise<void>;
+export declare function registerBoard(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/board/index.js

@@ -0,0 +1,96 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { webApiUrl } from "../../cloud.js";
+import { getProjectCredentials } from "../../utils/project-settings.js";
+/**
+ * Hidden from help until solutions launch: today's users see the CLI they
+ * have now, and the server refuses these commands for a team without the
+ * solutions switch (SOLACCESS-2).
+ */
+const HIDDEN_UNTIL_LAUNCH = { hidden: true };
+async function throughApp(path, extra) {
+    const { projectId, projectSecret } = getProjectCredentials();
+    const base = webApiUrl();
+    const response = await fetch(`${base}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId, projectSecret, ...extra }),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        // BOARD-CLI-3: every problem at once, each on its line — an agent that
+        // gets one problem per attempt spends a turn per typo.
+        const problems = (body.problems ?? [])
+            .map((problem) => problem.line === undefined
+            ? `  ${problem.message}`
+            : `  Line ${problem.line}: ${problem.message}`)
+            .join("\n");
+        throw new Error([body.error || response.statusText, problems]
+            .filter(Boolean)
+            .join("\n"));
+    }
+    return response;
+}
+export async function guideCommand() {
+    const response = await throughApp("/api/boards/guide", {});
+    const { guide } = (await response.json());
+    process.stdout.write(`${guide}\n`);
+}
+export async function createCommand(options) {
+    const yaml = readFileSync(resolve(options.file), "utf8");
+    const response = await throughApp("/api/boards/create", {
+        title: options.title,
+        description: options.description,
+        yaml,
+    });
+    const { boardId, message } = (await response.json());
+    console.log(`Created board ${boardId}. ${message} Submit it as board:${boardId}; read it back with: dotreq board show ${boardId}`);
+}
+export async function updateCommand(boardId, options) {
+    const yaml = readFileSync(resolve(options.file), "utf8");
+    const response = await throughApp("/api/boards/update", { boardId, yaml });
+    const { message } = (await response.json());
+    console.log(message);
+}
+export async function showCommand(boardId) {
+    const response = await throughApp("/api/boards/show", { boardId });
+    const { yaml } = (await response.json());
+    process.stdout.write(yaml.endsWith("\n") ? yaml : `${yaml}\n`);
+}
+export function registerBoard(program) {
+    const board = program
+        .command("board", HIDDEN_UNTIL_LAUNCH)
+        .description("Make and read discovery boards");
+    board
+        .command("guide")
+        .description("Print the board authoring guide: the YAML a board is written in, what each verb does, a complete example")
+        .action(wrap(guideCommand));
+    board
+        .command("create")
+        .description("Create a board in the project from a YAML file")
+        .requiredOption("--title <title>", "The board's title")
+        .option("--description <text>", "What the board explores")
+        .requiredOption("--file <path>", "The board file")
+        .action(wrap(createCommand));
+    board
+        .command("update <board-id>")
+        .description("Make a board say what a YAML file says")
+        .requiredOption("--file <path>", "The board file")
+        .action(wrap(updateCommand));
+    board
+        .command("show <board-id>")
+        .description("Print a board as the YAML it is written in")
+        .action(wrap(showCommand));
+}
+function wrap(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 1;
+        }
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/branch-merge.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `dotreq sync --branch-contributes <solution-id>` and `--branch-wins
+ * <solution-id>`: merge a solution's branch into main (BRANCH-8). Both sides
+ * are in the cloud, so no local file is read or written; the web app's merge
+ * route does it, as it does for the solution page's Merge action.
+ */
+type MergeDocument = {
+    title: string;
+    action: string;
+    because?: string;
+};
+type MergeRefusal = {
+    kind: "conflicts";
+    documents: string[];
+} | {
+    kind: "key";
+    key: string;
+    holder: string;
+    document: string;
+} | {
+    kind: "limit";
+    message: string;
+} | {
+    kind: "swap";
+    documents: string[];
+} | {
+    kind: "nothing";
+};
+type MergePlan = {
+    solution: {
+        title: string;
+    };
+    documents: MergeDocument[];
+    refusal: MergeRefusal | null;
+};
+type MergeOutcome = {
+    kind: "merged";
+    landed: string[];
+    plan: MergePlan;
+} | {
+    kind: "refused";
+    plan: MergePlan;
+} | {
+    kind: "no branch";
+} | {
+    kind: "stopped";
+    landed: string[];
+    at: string;
+    reason: string;
+    plan: MergePlan;
+};
+export type BranchMergeFlags = {
+    branchContributes?: string;
+    branchWins?: string;
+};
+/** The flags a branch merge can't be combined with (BRANCH-8.3). */
+declare const OTHER_FLAGS: readonly ["cloudContributes", "repoContributes", "cloudWins", "repoWins", "share", "project"];
+/**
+ * The merge a sync's flags ask for, or null when they ask for none. Throws,
+ * saying so, when they combine a merge with anything else (BRANCH-8.3).
+ */
+export declare function branchMergeOf(scope: string[], options: BranchMergeFlags & {
+    [K in (typeof OTHER_FLAGS)[number]]?: unknown;
+}): {
+    solutionId: string;
+    mode: "contributes" | "wins";
+} | null;
+/** What a merge says it did, line by line; and whether it did it. */
+export declare function describeMerge(outcome: MergeOutcome): {
+    lines: string[];
+    ok: boolean;
+};
+export declare function branchMergeCommand(merge: {
+    solutionId: string;
+    mode: "contributes" | "wins";
+}): Promise<void>;
+export {};
+//# sourceMappingURL=branch-merge.d.ts.map

package/dist/commands/branch-merge.js

@@ -0,0 +1,129 @@
+import { webApiUrl } from "../cloud.js";
+import { getProjectCredentials } from "../utils/project-settings.js";
+import { checkedOut } from "./solution/share.js";
+/** The flags a branch merge can't be combined with (BRANCH-8.3). */
+const OTHER_FLAGS = [
+    "cloudContributes",
+    "repoContributes",
+    "cloudWins",
+    "repoWins",
+    "share",
+    // The merge runs on the linked project's credential; a project named here
+    // would be quietly ignored, so it is refused instead.
+    "project",
+];
+/**
+ * The merge a sync's flags ask for, or null when they ask for none. Throws,
+ * saying so, when they combine a merge with anything else (BRANCH-8.3).
+ */
+export function branchMergeOf(scope, options) {
+    const contributes = options.branchContributes;
+    const wins = options.branchWins;
+    if (contributes === undefined && wins === undefined)
+        return null;
+    const combined = (contributes !== undefined && wins !== undefined) ||
+        scope.length > 0 ||
+        OTHER_FLAGS.some((flag) => options[flag]);
+    if (combined) {
+        throw new Error("A branch merge can't be combined with other sync flags or a scope: run `dotreq sync --branch-contributes <solution-id>` or `dotreq sync --branch-wins <solution-id>` on its own.");
+    }
+    return contributes !== undefined
+        ? { solutionId: contributes, mode: "contributes" }
+        : { solutionId: wins, mode: "wins" };
+}
+/** What a merge says it did, line by line; and whether it did it. */
+export function describeMerge(outcome) {
+    if (outcome.kind === "no branch") {
+        return {
+            lines: ["That solution has nothing on a branch to merge."],
+            ok: false,
+        };
+    }
+    const title = outcome.plan.solution.title;
+    if (outcome.kind === "merged") {
+        return {
+            lines: [
+                `Merged the "${title}" branch into main.`,
+                ...outcome.landed.map((doc) => `  landed: ${doc}`),
+            ],
+            ok: true,
+        };
+    }
+    if (outcome.kind === "stopped") {
+        return {
+            lines: [
+                `The "${title}" merge stopped at ${outcome.at}: ${outcome.reason}`,
+                ...outcome.landed.map((doc) => `  landed: ${doc}`),
+            ],
+            ok: false,
+        };
+    }
+    const refusal = outcome.plan.refusal;
+    switch (refusal.kind) {
+        case "conflicts":
+            return {
+                lines: [
+                    `Nothing merged: these documents on the "${title}" branch conflict with main.`,
+                    ...refusal.documents.map((doc) => `  conflict: ${doc}`),
+                    "Resolve them on the branch and merge again, or let the branch win with `dotreq sync --branch-wins <solution-id>`.",
+                ],
+                ok: false,
+            };
+        case "key":
+            return {
+                lines: [
+                    `Nothing merged: ${refusal.document} uses the requirement key ${refusal.key}, which "${refusal.holder}" on main has.`,
+                ],
+                ok: false,
+            };
+        case "limit":
+            return { lines: [`Nothing merged: ${refusal.message}`], ok: false };
+        case "swap":
+            return {
+                lines: [
+                    `Nothing merged: ${refusal.documents.join(" and ")} take each other's requirement keys, which can't land one at a time. Give one of them new keys on the branch.`,
+                ],
+                ok: false,
+            };
+        case "nothing":
+            return {
+                lines: [
+                    `Nothing to merge: every document on the "${title}" branch is already on main.`,
+                ],
+                ok: true,
+            };
+    }
+}
+export async function branchMergeCommand(merge) {
+    // SOLSHARE-5.0: a repository a solution's share command checked out holds
+    // no credential that merges; say so rather than asking for a link.
+    let credentials;
+    try {
+        credentials = getProjectCredentials();
+    }
+    catch (error) {
+        if (checkedOut().length > 0) {
+            throw new Error("Nothing merged: the share command you checked out with can't merge a solution's branch. Whoever runs the solution merges it, from the app.");
+        }
+        throw error;
+    }
+    const { projectId, projectSecret } = credentials;
+    const apiBaseUrl = webApiUrl();
+    const response = await fetch(`${apiBaseUrl}/api/branches/merge`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ...merge, projectId, projectSecret }),
+    });
+    const body = (await response.json().catch(() => null));
+    if (!body || !("kind" in body)) {
+        throw new Error(body?.error ??
+            `The merge failed (${response.status}).`);
+    }
+    const { lines, ok } = describeMerge(body);
+    for (const line of lines)
+        console.log(line);
+    // BRANCH-8.4: a merge that finds conflicts exits non-zero.
+    if (!ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=branch-merge.js.map

package/dist/commands/create-requirement-document.js

@@ -1,9 +1,9 @@
+import { convexUrl } from "../cloud.js";
 import { getProjectContext } from "../requirements/cloud-ai.js";
 import { loadAllRequirements } from "../requirements/index.js";
 import { generateStyleGuide } from "../requirements/style-guide.js";
 import { readLocalStyleGuide } from "../requirements/style-guide-file.js";
 import { findProjectRoot, getProjectCredentials, } from "../utils/project-settings.js";
-const CONVEX_URL = "https://data.dotrequirements.io";
 export async function createRequirementDocumentCommand(filePath) {
     const workspaceRoot = process.cwd();
     // CLI-CREATE-DOC-1.1 / .2: discover existing patterns from the workspace.
@@ -24,7 +24,7 @@ export async function createRequirementDocumentCommand(filePath) {
     if (projectRoot) {
         try {
             const { projectId, projectSecret } = getProjectCredentials(workspaceRoot);
-            const contextData = await getProjectContext(projectId, projectSecret, CONVEX_URL);
+            const contextData = await getProjectContext(projectId, projectSecret, convexUrl());
             customStyleGuidance = contextData?.requirementsStyleContext ?? null;
         }
         catch {

package/dist/commands/diff.js

@@ -5,16 +5,17 @@
  * the detail one level. Exits 0 regardless of verdicts unless `--exit-code` is
  * passed, which makes any non-in-sync document exit 1 (the CI drift gate).
  */
-import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, filterByScope, formatUnitDetail, formatVerdictLine, resolutionHint, } from "../sync/index.js";
+import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, filterByScope, foreignDocumentNotes, formatUnitDetail, formatVerdictLine, resolutionHint, } from "../sync/index.js";
 import { brand } from "../utils/brand.js";
 import { resolveCloudAuth } from "./sync-common.js";
 export async function diffCommand(scope, options) {
     const workspaceRoot = process.cwd();
     const auth = resolveCloudAuth(options);
-    const [local, cloud] = await Promise.all([
-        acquireLocalSnapshot(workspaceRoot),
-        acquireCloudSnapshot(auth),
-    ]);
+    // SOLACCESS-2.2: as the sync carries them.
+    const cloud = await acquireCloudSnapshot(auth);
+    const local = await acquireLocalSnapshot(workspaceRoot, undefined, {
+        solutions: cloud.solutions === true,
+    });
     const comparison = compareSnapshots(local, cloud);
     const { documents, unmatched } = filterByScope(comparison, scope, workspaceRoot);
     for (const token of unmatched) {
@@ -38,12 +39,21 @@ export async function diffCommand(scope, options) {
         console.log("No documents to compare.");
         return;
     }
+    // SYNC-FAIL-5: a file whose id names another project's document is only
+    // in the repo, and a sync will refuse it; say so here as the sync will.
+    const foreign = await foreignDocumentNotes(auth, documents.flatMap((d) => d.verdict === "only_in_repo" && d.documentId ? [d.documentId] : []));
     console.log(`\n=== Repo vs ${brand} cloud ===\n`);
     for (const doc of documents) {
         console.log(formatVerdictLine(doc));
         if (doc.verdict === "invalid_file" && doc.error) {
             console.log(`      ${doc.error}`);
         }
+        const foreignNote = doc.verdict === "only_in_repo" && doc.documentId
+            ? foreign.get(doc.documentId)
+            : undefined;
+        if (foreignNote) {
+            console.log(`      ${foreignNote}`);
+        }
         if (verbose && doc.details && doc.details.length > 0) {
             for (const detail of doc.details) {
                 console.log(formatUnitDetail(detail));

package/dist/commands/init.js

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { ConvexHttpClient } from "convex/browser";
-import { getConvexUrl } from "../config.js";
+import { convexUrl } from "../cloud.js";
 import { api } from "../convex.js";
 import { generateStyleGuideBody } from "../requirements/style-guide.js";
 import { generateExampleRequirements } from "../templates/example-requirements.js";
 import { generateRequirementsReadme } from "../templates/requirements-readme.js";
 import { brand } from "../utils/brand.js";
+import { commandErrorMessage } from "../utils/command-error.js";
 import { ensureGitignore } from "../utils/gitignore.js";
 import { executeOAuthFlow } from "../utils/oauth-flow.js";
 import { detectProjectName } from "../utils/project-name.js";
@@ -69,7 +70,7 @@ export async function initCommand(options = {}) {
         }
     }
     catch (error) {
-        console.error(`\n✗ Error: ${error instanceof Error ? error.message : String(error)}`);
+        console.error(`\n✗ Error: ${commandErrorMessage(error)}`);
         // INIT-11: Network error guidance
         if (error instanceof Error && error.message.includes("fetch")) {
             console.error("\nCheck your internet connection and try again.");
@@ -130,7 +131,7 @@ async function authenticatedFlow(cwd, options) {
         return false;
     }
     // Set up authenticated client using the session token
-    const client = new ConvexHttpClient(getConvexUrl());
+    const client = new ConvexHttpClient(convexUrl());
     client.setAuth(oauthResult.accessToken);
     // INIT-18: Select team
     const selectedTeam = await selectTeam(client);
@@ -216,9 +217,9 @@ async function selectTeam(client) {
  */
 async function chooseProjectAction(client, teamId) {
     // INIT-7.3: Check if team has existing projects the user can access
-    const projectsWithSecrets = (await client.query(api.projectSecrets.queries.listOwnSecretsForTeam, 
+    const projectsWithSecrets = (await client.query(api.projectSecrets.queries.listOwnForTeam, 
     // biome-ignore lint/suspicious/noExplicitAny: CLI workspace doesn't import convex's branded Id<"teams"> type; the runtime value is a plain string the convex server validates.
-    { target: { type: "team", id: teamId } }));
+    { teamId: teamId }));
     if (projectsWithSecrets.length === 0) {
         // No existing projects, only offer create
         const confirmed = await promptConfirm("This team has no projects. Create a new one?", true);
@@ -315,7 +316,7 @@ async function connectExistingProjectFlow(cwd, client, team) {
  */
 async function inviteFlow(cwd, token) {
     // MEMBERSHIP-18.0: Validate token before auth (no auth needed for this query)
-    const client = new ConvexHttpClient(getConvexUrl());
+    const client = new ConvexHttpClient(convexUrl());
     console.log("Validating invite token...");
     const inviteInfo = await client.query(api.teamInvites.queries.getInviteInfo, {
         token,