@iann29/synapse 1.6.17 → 1.7.0

package/README.md

@@ -15,6 +15,26 @@ npm install -g @iann29/synapse
 synapse --help
 ```
 
+### Windows: ensure the npm global bin directory is in PATH
+
+On a fresh Node.js install, Windows does **not** always add
+`%APPDATA%\npm` to the user PATH. After `npm install -g`, the
+`synapse` binary exists but `synapse --help` errors with
+*"not recognised as the name of a cmdlet"*. Fix once in PowerShell:
+
+```powershell
+[Environment]::SetEnvironmentVariable(
+  'PATH',
+  "$([Environment]::GetEnvironmentVariable('PATH','User'));$env:APPDATA\npm",
+  'User'
+)
+```
+
+Close every terminal (and your IDE — VS Code caches the env at launch)
+and reopen. `synapse --help` should now print the usage. This is a
+one-time, Node-installer-version-dependent issue; it is not specific
+to this package.
+
 For one app/project:
 
 ```bash

package/bin/synapse.js

@@ -9,17 +9,29 @@ const {
   readProjectConfig,
   writeProjectConfig,
 } = require("../lib/project");
-const { askCredentials, choose } = require("../lib/prompts");
+const { BACK, askCredentials, choose, confirm } = require("../lib/prompts");
+const colors = require("../lib/colors");
 const { runConvex } = require("../lib/convex");
 
+function debugLog(msg) {
+  if (process.env.DEBUG_SYNAPSE) {
+    process.stderr.write(`[DEBUG] ${msg}\n`);
+  }
+}
+
 function usage() {
   return `Usage:
   synapse login <url>
   synapse logout
   synapse whoami
   synapse select
+  synapse dev [...args]                                    Run \`convex dev\` against the linked dev deployment.
+  synapse deploy [--yes] [...args]                          Run \`convex deploy\` against the linked prod deployment (asks for confirmation).
   synapse credentials <deployment> [--format env|shell|json]
-  synapse convex [--target dev|prod] [...args]
+  synapse convex [--target dev|prod] [...args]              Escape hatch for any other \`convex\` subcommand.
+
+Tip: \`synapse select\` writes the deployment credentials to .env.local, so you can also
+run \`npx convex <args>\` directly without going through this wrapper.
 `;
 }
 
@@ -73,12 +85,13 @@ function teamRef(team) {
 }
 
 function deploymentLabel(deployment) {
-  const bits = [deployment.name];
-  if (deployment.deploymentType || deployment.type) {
-    bits.push(deployment.deploymentType || deployment.type);
+  const bits = [colors.bold(deployment.name)];
+  const type = deployment.deploymentType || deployment.type;
+  if (type) {
+    bits.push(colors.dim(type));
   }
   if (deployment.status) {
-    bits.push(deployment.status);
+    bits.push(colors.statusBadge(deployment.status));
   }
   return bits.filter(Boolean).join(" - ");
 }
@@ -96,16 +109,21 @@ function sortDeploymentsForChoice(deployments) {
   });
 }
 
-async function chooseDeploymentForType(type, deployments) {
+async function chooseDeploymentForType(type, deployments, chooseOpts = {}) {
   const matches = sortDeploymentsForChoice(
     deployments.filter((d) => deploymentType(d) === type && d.status !== "deleted"),
   );
+  debugLog(
+    `chooseDeploymentForType(${type}): matched ${matches.length} of ${deployments.length} ` +
+    `(types: ${deployments.map((d) => deploymentType(d) || "?").join(",")})`,
+  );
   if (matches.length === 0) {
     return null;
   }
   return await choose(
     `${type} deployments`,
     matches.map((d) => ({ label: deploymentLabel(d), value: d })),
+    { singularLabel: `${type} deployment`, ...chooseOpts },
   );
 }
 
@@ -259,18 +277,94 @@ async function whoami() {
   process.stdout.write(`${name ? `${name} ` : ""}<${email}> on ${cfg.baseUrl}\n`);
 }
 
+// selectDeployment walks the operator through team → project → dev → prod
+// pickers, then writes .synapse/project.json + .env.local. Implemented as a
+// small state machine so the user can type `b` / `back` at any step to
+// re-choose the previous selection without restarting the whole CLI.
+//
+// Network results are cached per (team, project) so back-navigation stays
+// snappy and doesn't burn pagination roundtrips. `DEBUG_SYNAPSE=1` dumps
+// the raw lists at each step — useful when an expected deployment is
+// missing from the menu.
 async function selectDeployment() {
   const { cfg, api } = clientFromConfig();
-  const teams = await api.teams();
-  const team = await choose("teams", teams.map((t) => ({ label: labelName(t), value: t })));
-  const projects = await api.projects(teamRef(team));
-  const project = await choose("projects", projects.map((p) => ({ label: labelName(p), value: p })));
-  const deployments = await api.deployments(project.id);
-  const dev = await chooseDeploymentForType("dev", deployments);
-  if (!dev) {
-    throw new Error("No dev deployments available in this project. Create one first.");
+
+  const cache = {
+    teamsList: null,
+    projectsByTeamKey: new Map(),
+    deploymentsByProjectId: new Map(),
+  };
+  async function fetchTeams() {
+    if (!cache.teamsList) {
+      cache.teamsList = await api.teams();
+      debugLog(`teams loaded: ${cache.teamsList.length}`);
+    }
+    return cache.teamsList;
+  }
+  async function fetchProjects(team) {
+    const key = team.id || team.slug || team.name;
+    if (!cache.projectsByTeamKey.has(key)) {
+      const projects = await api.projects(teamRef(team));
+      cache.projectsByTeamKey.set(key, projects);
+      debugLog(`projects for team ${key}: ${projects.length}`);
+    }
+    return cache.projectsByTeamKey.get(key);
   }
-  const prod = await chooseDeploymentForType("prod", deployments);
+  async function fetchDeployments(project) {
+    if (!cache.deploymentsByProjectId.has(project.id)) {
+      const deployments = await api.deployments(project.id);
+      cache.deploymentsByProjectId.set(project.id, deployments);
+      debugLog(`deployments for project ${project.id}: ${deployments.length}`);
+    }
+    return cache.deploymentsByProjectId.get(project.id);
+  }
+
+  let team = null;
+  let project = null;
+  let dev = null;
+  let prod = null;
+  let step = "team";
+  while (step !== "done") {
+    if (step === "team") {
+      const teams = await fetchTeams();
+      // Back from team would be "exit" — not useful at the top of the flow.
+      const picked = await choose(
+        "teams",
+        teams.map((t) => ({ label: labelName(t), value: t })),
+        { singularLabel: "team", allowBack: false },
+      );
+      team = picked;
+      step = "project";
+    } else if (step === "project") {
+      const projects = await fetchProjects(team);
+      const picked = await choose(
+        "projects",
+        projects.map((p) => ({ label: labelName(p), value: p })),
+        { singularLabel: "project", allowBack: true },
+      );
+      if (picked === BACK) { step = "team"; continue; }
+      project = picked;
+      step = "dev";
+    } else if (step === "dev") {
+      const deployments = await fetchDeployments(project);
+      const picked = await chooseDeploymentForType("dev", deployments, { allowBack: true });
+      if (picked === BACK) { step = "project"; continue; }
+      if (picked === null) {
+        throw new Error(
+          "No dev deployments available in this project. Create one first in the dashboard.",
+        );
+      }
+      dev = picked;
+      step = "prod";
+    } else if (step === "prod") {
+      const deployments = await fetchDeployments(project);
+      const picked = await chooseDeploymentForType("prod", deployments, { allowBack: true });
+      if (picked === BACK) { step = "dev"; continue; }
+      prod = picked; // null is a valid outcome here (project has no prod yet)
+      step = "done";
+    }
+  }
+
   const projectPath = writeProjectConfig(
     process.cwd(),
     buildProjectConfig({
@@ -282,16 +376,34 @@ async function selectDeployment() {
   );
   const creds = await api.cliCredentials(dev.name);
   const envPath = writeProjectEnv(process.cwd(), creds);
-  process.stderr.write(`Linked ${labelName(project)} to ${projectPath}.\n`);
-  process.stderr.write(`Selected dev deployment ${dev.name}. Updated ${envPath}.\n`);
+
+  process.stderr.write(`\nLinked ${labelName(project)} to ${projectPath}.\n`);
+  process.stderr.write(`Selected dev deployment ${colors.bold(dev.name)}. Updated ${envPath}.\n`);
   if (prod) {
-    process.stderr.write(`Selected prod deployment ${prod.name}.\n`);
+    process.stderr.write(`Selected prod deployment ${colors.bold(prod.name)}.\n`);
   } else {
-    process.stderr.write("Warning: no prod deployment found. `synapse convex deploy` will require a prod deployment saved by `synapse select`.\n");
+    process.stderr.write(
+      `\n${colors.yellow("Warning:")} no prod deployment found. ` +
+      "`synapse deploy` (and `synapse convex deploy`) will fail with a clear " +
+      "error until you create a prod deployment and run `synapse select` again.\n",
+    );
   }
   if (process.env.CONVEX_DEPLOYMENT) {
-    process.stderr.write("Warning: shell CONVEX_DEPLOYMENT is set. Use `synapse convex ...` or unset it before running `npx convex` directly.\n");
+    process.stderr.write(
+      `\n${colors.yellow("Warning:")} shell CONVEX_DEPLOYMENT is set. ` +
+      "Use `synapse dev` / `synapse deploy` / `synapse convex ...` " +
+      "or unset CONVEX_DEPLOYMENT before running `npx convex` directly.\n",
+    );
   }
+  // Discoverability hint (P3-012). The upstream Convex CLI's `dev` command
+  // is what pushes the project's schema/functions and starts a dev server;
+  // many operators land here from frameworks (Next/Vite) without knowing
+  // that, then hit "page hangs forever" the first time their client tries
+  // to query a backend that has no code deployed yet. Spell it out.
+  process.stderr.write(
+    `\nNext step: run ${colors.bold("synapse dev")} (or ${colors.bold("npx convex dev")}) once in this directory ` +
+    "to push your schema and watch for changes.\n",
+  );
 }
 
 async function credentials(args) {
@@ -327,6 +439,71 @@ async function convex(args) {
   process.exitCode = code;
 }
 
+// extractYesFlag pulls --yes / -y out of an arg vector so the rest can be
+// passed verbatim to the underlying `convex` invocation. We strip only
+// these synapse-level flags; everything else is forwarded.
+function extractYesFlag(args) {
+  let yes = false;
+  const rest = [];
+  for (const arg of args) {
+    if (arg === "--yes" || arg === "-y") {
+      yes = true;
+    } else {
+      rest.push(arg);
+    }
+  }
+  return { yes, rest };
+}
+
+// dev is a convenience for `synapse convex --target dev dev`. We delegate
+// to the existing convex pipeline so target resolution, credential fetching,
+// and env-var sanitization stay in one place.
+//
+// The `convexImpl` seam exists so unit tests can short-circuit before
+// runConvex actually spawns `npx`. Production wiring uses the local
+// `convex` function above unchanged.
+async function dev(args, { convexImpl = convex } = {}) {
+  return await convexImpl(["--target", "dev", "dev", ...args]);
+}
+
+// deploy is the same delegation pattern as `dev`, but with a confirmation
+// gate because publishing to prod is destructive (overwrites functions and
+// schema). The gate is skippable via --yes / -y for CI use. Non-interactive
+// callers without --yes get a clear refusal rather than a hang on
+// readline.question() that never fires.
+//
+// We resolve the prod deployment name from the local project metadata so the
+// prompt names the exact target. When there's no metadata (no `synapse
+// select` yet), we let `convex()` produce its own "run select first" error
+// without prompting — the operator obviously isn't ready to deploy.
+async function deploy(args, {
+  input = process.stdin,
+  output = process.stderr,
+  confirmImpl = confirm,
+  convexImpl = convex,
+} = {}) {
+  const { yes, rest } = extractYesFlag(args);
+  const projectConfig = readProjectConfig(process.cwd());
+  const deploymentName = deploymentNameForTarget(projectConfig, "prod");
+  if (deploymentName && !yes) {
+    if (!input.isTTY) {
+      throw new Error(
+        "synapse deploy needs confirmation. Pass --yes to skip in non-interactive contexts (CI, scripts), " +
+        "or run `synapse deploy` again inside a regular terminal.",
+      );
+    }
+    const ok = await confirmImpl(
+      `About to run \`convex deploy\` against PROD deployment ${deploymentName}. Continue? [y/N] `,
+      { input, output, defaultAnswer: false },
+    );
+    if (!ok) {
+      output.write("Deploy cancelled.\n");
+      return;
+    }
+  }
+  return await convexImpl(["--target", "prod", "deploy", ...rest]);
+}
+
 async function main(argv) {
   const [command, ...args] = argv;
   switch (command) {
@@ -340,6 +517,10 @@ async function main(argv) {
       return await selectDeployment();
     case "credentials":
       return await credentials(args);
+    case "dev":
+      return await dev(args);
+    case "deploy":
+      return await deploy(args);
     case "convex":
       return await convex(args);
     case "-h":
@@ -356,6 +537,16 @@ async function main(argv) {
 if (require.main === module) {
   main(process.argv.slice(2)).catch((err) => {
     process.stderr.write(`${err.message}\n`);
+    // Surface a concrete next step for the most common failure mode —
+    // the user typed a Synapse URL that doesn't resolve or whose server
+    // refused the connection. Without this hint, "fetch failed" reads
+    // like a Node bug instead of a config / connectivity problem.
+    if (err && err.code === "network_error") {
+      process.stderr.write(
+        "Hint: double-check the URL is reachable from this machine (try `curl <url>/v1/install_status`) " +
+        "and that the Synapse server is running.\n",
+      );
+    }
     process.exitCode = 1;
   });
 }
@@ -363,6 +554,9 @@ if (require.main === module) {
 module.exports = {
   chooseDeploymentForType,
   clientFromConfig,
+  deploy,
+  dev,
+  extractYesFlag,
   formatCredentials,
   inferConvexTarget,
   main,

package/lib/api.js

@@ -75,10 +75,23 @@ class SynapseAPI {
         pageURL.searchParams.set("cursor", cursor);
       }
       const page = await this.request("GET", `${pageURL.pathname}${pageURL.search}`, undefined, { includeHeaders: true });
-      if (!Array.isArray(page.data)) {
-        throw new SynapseAPIError(0, "bad_response", `Expected ${path} to return a JSON array`);
+      // Backend currently returns a bare JSON array for every paginated
+      // endpoint, but the dashboard already tolerates both `[...]` and
+      // `{ <noun>: [...] }` (see `collectPaginated` in dashboard/lib/api.ts).
+      // Mirror that resilience here so a future server-side reshape doesn't
+      // brick `synapse select` for every CLI user simultaneously.
+      const arr = extractListPayload(page.data);
+      if (arr === null) {
+        const shape = page.data && typeof page.data === "object"
+          ? `object with keys [${Object.keys(page.data).join(", ")}]`
+          : typeof page.data;
+        throw new SynapseAPIError(
+          0,
+          "bad_response",
+          `Expected ${path} to return a JSON array (got ${shape})`,
+        );
       }
-      items.push(...page.data);
+      items.push(...arr);
       cursor = page.headers.get("x-next-cursor") || "";
     } while (cursor);
     return items;
@@ -113,7 +126,36 @@ class SynapseAPI {
   }
 }
 
+// Known envelope keys, in priority order. We try these explicitly before
+// falling back to a generic "first array-valued property" lookup so a
+// future endpoint that wraps results in `{ items: [...] }` (or similar)
+// keeps working. The fallback handles the unlikely case of a renamed
+// envelope without crashing the CLI.
+const KNOWN_LIST_KEYS = [
+  "teams",
+  "projects",
+  "deployments",
+  "members",
+  "items",
+  "data",
+  "results",
+];
+
+function extractListPayload(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    for (const key of KNOWN_LIST_KEYS) {
+      if (Array.isArray(data[key])) return data[key];
+    }
+    for (const value of Object.values(data)) {
+      if (Array.isArray(value)) return value;
+    }
+  }
+  return null;
+}
+
 module.exports = {
   SynapseAPI,
   SynapseAPIError,
+  extractListPayload,
 };

package/lib/colors.js

@@ -0,0 +1,51 @@
+// Zero-dependency ANSI helpers. Each helper returns its argument as-is when
+// the terminal does not support colour (stdout is not a TTY) or the user
+// opted out via NO_COLOR (https://no-color.org). Checked at call time, not
+// at require time, so tests that toggle `process.env.NO_COLOR` or that run
+// under `node --test` (no TTY) get plain output without further wiring.
+//
+// We deliberately do not depend on `chalk` / `kleur` / etc — the @iann29/
+// synapse package ships zero runtime deps, and a handful of escape codes
+// don't justify breaking that.
+
+function enabled(stream = process.stdout) {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true") return true;
+  return Boolean(stream && stream.isTTY);
+}
+
+function wrap(code) {
+  return (value, stream) =>
+    enabled(stream) ? `\x1b[${code}m${value}\x1b[0m` : String(value);
+}
+
+// Renders the status portion of a deployment row. `running` reads as success,
+// `failed` as error, `provisioning` as in-flight, anything else as dim noise.
+// Falls through to the plain string when colour is off so logs grep cleanly.
+function statusBadge(status, stream) {
+  switch (status) {
+    case "running":
+      return module.exports.green(status, stream);
+    case "failed":
+    case "errored":
+      return module.exports.red(status, stream);
+    case "provisioning":
+      return module.exports.yellow(status, stream);
+    case "stopped":
+    case "deleted":
+      return module.exports.dim(status, stream);
+    default:
+      return String(status || "");
+  }
+}
+
+module.exports = {
+  enabled,
+  bold: wrap("1"),
+  dim: wrap("2"),
+  red: wrap("31"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  cyan: wrap("36"),
+  statusBadge,
+};

package/lib/convex.js

@@ -29,12 +29,29 @@ function buildConvexEnv(source = process.env, projectEnv = {}, overrides = {}) {
   return env;
 }
 
-function runConvex(args, { env = process.env, stdio = "inherit", credentials = null, spawnImpl = spawn } = {}) {
-  const executable = process.platform === "win32" ? "npx.cmd" : "npx";
+// Node 18.20.0+, 20.12.0+, 22.0.0+ refuse to spawn `.cmd`/`.bat` shims on
+// Windows without `shell: true` (CVE-2024-27980 mitigation). `npx` on Windows
+// is `npx.cmd`, so without this flag every `synapse convex …` invocation
+// dies with `spawn EINVAL`. Safe to enable because the argv is controlled
+// by us — `"convex"` is literal and the remaining args come from the user's
+// CLI line, which `child_process` quotes when handing them to `cmd.exe`.
+function shouldUseShell(platform = process.platform) {
+  return platform === "win32";
+}
+
+function runConvex(args, {
+  env = process.env,
+  stdio = "inherit",
+  credentials = null,
+  spawnImpl = spawn,
+  platform = process.platform,
+} = {}) {
+  const executable = platform === "win32" ? "npx.cmd" : "npx";
   const projectEnv = readProjectEnv(process.cwd());
   const child = spawnImpl(executable, ["convex", ...args], {
     env: buildConvexEnv(env, projectEnv, envFromCredentials(credentials)),
     stdio,
+    shell: shouldUseShell(platform),
   });
 
   return new Promise((resolve, reject) => {
@@ -53,4 +70,5 @@ module.exports = {
   buildConvexEnv,
   envFromCredentials,
   runConvex,
+  shouldUseShell,
 };

package/lib/prompts.js

@@ -1,5 +1,10 @@
 const readline = require("node:readline");
 
+// Sentinel returned by `choose` when the user asks to go back to the
+// previous step. Use a Symbol so it can never collide with a legitimate
+// choice payload.
+const BACK = Symbol("synapse-choose-back");
+
 function ask(question, { input = process.stdin, output = process.stderr } = {}) {
   const rl = readline.createInterface({ input, output });
   return new Promise((resolve) => {
@@ -89,12 +94,69 @@ async function askCredentials({ input = process.stdin, output = process.stderr }
   };
 }
 
-async function choose(label, choices, { input = process.stdin, output = process.stderr } = {}) {
+// confirm prompts the user with a yes/no question and resolves to a boolean.
+//
+// - Empty answer applies `defaultAnswer` (so `[y/N]` matches "no by default"
+//   and `[Y/n]` matches "yes by default"). The hint in the question is the
+//   caller's responsibility — we render the prompt literally.
+// - "y" / "yes" / "n" / "no" (case-insensitive) are accepted.
+// - Anything else re-prompts with a tip, capped at `maxAttempts` to keep
+//   pasted-shell-history scenarios from looping forever.
+// - Non-interactive callers (no TTY) cannot disambiguate — they must use a
+//   skip-confirmation flag at the call site instead of relying on `confirm`.
+//
+// We open a single readline interface for the whole prompt session.
+// Calling `ask()` multiple times would re-create the interface and re-bind
+// `data` listeners on the input stream — which is fine for real stdin but
+// produces flaky behaviour on a buffered PassThrough where the second
+// listener can't see data the first consumed. One rl, multiple questions.
+async function confirm(question, {
+  input = process.stdin,
+  output = process.stderr,
+  defaultAnswer = false,
+  maxAttempts = 3,
+} = {}) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      const raw = await new Promise((resolve) => rl.question(question, resolve));
+      const answer = raw.trim().toLowerCase();
+      if (answer === "") return defaultAnswer;
+      if (answer === "y" || answer === "yes") return true;
+      if (answer === "n" || answer === "no") return false;
+      output.write("Please answer y or n.\n");
+    }
+    throw new Error("Confirmation prompt cancelled after too many invalid answers");
+  } finally {
+    rl.close();
+  }
+}
+
+// choose prompts the user to pick one of `choices`.
+//
+// - `label` is the plural noun used for the menu header ("dev deployments").
+// - `singularLabel` defaults to `label` stripped of a trailing "s" — it's
+//   the noun used when only one option exists and we auto-select silently.
+//   Pass a custom value when the strip heuristic produces something
+//   awkward ("members" → "member" is fine; "people" → "peopl" is not).
+// - `allowBack` lets the user type "b" / "back" / "0" to return the BACK
+//   sentinel, which the caller maps to a previous step.
+// - `maxInvalid` caps how many garbage answers in a row we tolerate
+//   before throwing. Protects against pasted shell history / broken
+//   stdin where the loop would otherwise spin forever.
+async function choose(label, choices, {
+  input = process.stdin,
+  output = process.stderr,
+  singularLabel,
+  allowBack = false,
+  maxInvalid = 3,
+} = {}) {
   if (!Array.isArray(choices) || choices.length === 0) {
     throw new Error(`No ${label} available.`);
   }
+  const singular = singularLabel || label.replace(/s$/, "") || label;
   if (choices.length === 1) {
-    output.write(`Using ${label}: ${choices[0].label}\n`);
+    output.write(`Auto-selected ${singular}: ${choices[0].label} (only one available)\n`);
     return choices[0].value;
   }
 
@@ -103,20 +165,34 @@ async function choose(label, choices, { input = process.stdin, output = process.
     output.write(`  ${index + 1}. ${choice.label}\n`);
   });
 
+  const hint = allowBack
+    ? `[1-${choices.length}, b=back]`
+    : `[1-${choices.length}]`;
+
+  let invalid = 0;
   while (true) {
-    const answer = await ask(`Choose ${label} [1-${choices.length}]: `, { input, output });
+    const answer = (await ask(`Choose ${label} ${hint}: `, { input, output })).trim();
+    if (allowBack && (answer === "b" || answer === "B" || answer === "back" || answer === "0")) {
+      return BACK;
+    }
     const n = Number.parseInt(answer, 10);
     if (Number.isInteger(n) && n >= 1 && n <= choices.length) {
       return choices[n - 1].value;
     }
-    output.write(`Enter a number from 1 to ${choices.length}.\n`);
+    invalid += 1;
+    if (invalid >= maxInvalid) {
+      throw new Error(`Cancelled ${label} prompt after ${invalid} invalid answers`);
+    }
+    output.write(`Enter a number from 1 to ${choices.length}${allowBack ? " (or 'b' to go back)" : ""}.\n`);
   }
 }
 
 module.exports = {
+  BACK,
   ask,
   askCredentials,
   askHidden,
   choose,
+  confirm,
   parseCredentialsInput,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iann29/synapse",
-  "version": "1.6.17",
+  "version": "1.7.0",
   "description": "Thin CLI wrapper for using the official Convex CLI with Synapse-managed deployments.",
   "license": "Apache-2.0",
   "repository": {