@iann29/synapse 1.8.6 → 1.8.7

package/lib/commands/env-set.js

@@ -0,0 +1,129 @@
+// `synapse env set NAME=value [NAME2=value2 ...] [--for=dev,prod] [--project=<id>] [--json]`
+//
+// Batch-sets project-default env vars. Multiple positionals = single
+// transactional update on the backend (the handler wraps the whole
+// `changes` array in a BEGIN/COMMIT). If any value is rejected the
+// whole batch rolls back.
+//
+// Value parsing: split on the FIRST `=`. So `FOO=a=b` sets FOO to "a=b".
+// Names must match /^[A-Z_][A-Z0-9_]*$/ — same shape the Convex backend
+// accepts (uppercase letters, digits, underscore; leading non-digit).
+
+const colors = require("../colors");
+const { extractFlags, resolveProject } = require("./_resource");
+
+const NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+const VALID_FORS = new Set(["dev", "prod", "preview"]);
+
+// Splits `NAME=value` on the FIRST `=`. Returns { name, value } or
+// throws when the shape is wrong. Empty value is OK ("FOO=" sets to "").
+function parsePair(arg) {
+  const eq = arg.indexOf("=");
+  if (eq <= 0) {
+    throw new Error(
+      `Invalid env assignment: ${JSON.stringify(arg)}. Expected NAME=value.`,
+    );
+  }
+  const name = arg.slice(0, eq);
+  const value = arg.slice(eq + 1);
+  if (!NAME_RE.test(name)) {
+    throw new Error(
+      `Invalid env name: ${JSON.stringify(name)}. Names must match [A-Z_][A-Z0-9_]*.`,
+    );
+  }
+  return { name, value };
+}
+
+// Comma-split + trim + dedupe a `--for=dev,prod` argument. Empty
+// returns null (= "use default"). Errors on unknown types.
+function parseFor(raw) {
+  if (raw === undefined || raw === null || raw === true) return null;
+  const trimmed = String(raw).trim();
+  if (trimmed === "") return null;
+  const parts = [
+    ...new Set(trimmed.split(",").map((s) => s.trim().toLowerCase())),
+  ].filter(Boolean);
+  for (const p of parts) {
+    if (!VALID_FORS.has(p)) {
+      throw new Error(
+        `Invalid --for entry: ${p}. Must be one of: ${[...VALID_FORS].join(", ")}.`,
+      );
+    }
+  }
+  return parts;
+}
+
+module.exports = {
+  name: "env set",
+  summary: "Set one or more project-default environment variables.",
+  usage:
+    "synapse env set NAME=value [NAME2=value2 ...] [--for=dev,prod] [--project=<id>] [--json]",
+  description: `Calls POST /v1/projects/{id}/update_default_environment_variables with op=set. Multiple pairs are applied in a single transaction. Names follow the [A-Z_][A-Z0-9_]* convention; values are byte-preserved (whitespace, quotes, '=' all OK).
+
+Flags:
+  --for=dev,prod     Limit the var to specific deploymentTypes
+                     (comma-separated). Omitted: backend defaults
+                     (typically: all types).
+  --project=<id>     Override the linked project.
+  --json             Machine-readable output.
+
+Examples:
+  synapse env set OPENAI_API_KEY=sk-abc...
+  synapse env set FOO=bar BAZ=qux --for=prod
+  synapse env set REDIS_URL='rediss://user:pass@host:6379/0'`,
+
+  // Re-exports for tests.
+  parsePair,
+  parseFor,
+  NAME_RE,
+
+  async run(args, ctx) {
+    const { flags, rest } = extractFlags(args, {
+      string: ["for", "project"],
+      boolean: ["json"],
+    });
+    if (rest.length === 0) {
+      throw new Error(
+        "Usage: synapse env set NAME=value [NAME2=value2 ...] [--for=...]",
+      );
+    }
+    const forList = parseFor(flags.for);
+    const pairs = rest.map(parsePair);
+
+    const resolveArgs = flags.project ? [`--project=${flags.project}`] : [];
+    const { projectId, source } = resolveProject(ctx, resolveArgs);
+
+    const changes = pairs.map(({ name, value }) => ({
+      op: "set",
+      name,
+      value,
+      ...(forList ? { deploymentTypes: forList } : {}),
+    }));
+
+    if (!ctx.out.json) {
+      ctx.out.info(
+        `Setting ${pairs.length} env var${pairs.length > 1 ? "s" : ""} on project ${projectId}${forList ? ` (for: ${forList.join(",")})` : ""}…`,
+      );
+    }
+    await ctx.api.updateProjectEnvVars(projectId, changes);
+
+    ctx.out.result(
+      {
+        projectId,
+        projectSource: source,
+        applied: changes.length,
+        changes: changes.map((c) => ({ name: c.name, deploymentTypes: c.deploymentTypes ?? null })),
+      },
+      (_d, { stdout }) => {
+        for (const { name } of pairs) {
+          stdout.write(`${colors.green("+")} ${colors.bold(name)}\n`);
+        }
+        stdout.write(
+          colors.dim(
+            "These defaults are injected into NEW deployments. To apply to existing deployments, run `synapse convex env set` per deployment, or re-create them.\n",
+          ),
+        );
+      },
+    );
+  },
+};

package/lib/commands/env-unset.js

@@ -0,0 +1,77 @@
+// `synapse env unset NAME [NAME2 ...] [--project=<id>] [--json]`
+//
+// Batch-deletes project-default env vars. Sends op=delete for each
+// name in a single transactional update. Unknown names are not an
+// error server-side (the DELETE is idempotent), but we surface a
+// warning when ALL passed names were unknown — usually a typo.
+
+const colors = require("../colors");
+const { extractFlags, resolveProject } = require("./_resource");
+
+const NAME_RE = /^[A-Z_][A-Z0-9_]*$/;
+
+module.exports = {
+  name: "env unset",
+  summary: "Delete one or more project-default environment variables.",
+  usage: "synapse env unset NAME [NAME2 ...] [--project=<id>] [--json]",
+  description: `Calls POST /v1/projects/{id}/update_default_environment_variables with op=delete. Idempotent — deleting a name that doesn't exist is silent.
+
+Flags:
+  --project=<id>     Override the linked project.
+  --json             Machine-readable output.
+
+Examples:
+  synapse env unset OLD_API_KEY
+  synapse env unset FOO BAR BAZ`,
+
+  async run(args, ctx) {
+    const { flags, rest } = extractFlags(args, {
+      string: ["project"],
+      boolean: ["json"],
+    });
+    if (rest.length === 0) {
+      throw new Error("Usage: synapse env unset NAME [NAME2 ...]");
+    }
+    for (const name of rest) {
+      if (!NAME_RE.test(name)) {
+        throw new Error(
+          `Invalid env name: ${JSON.stringify(name)}. Names must match [A-Z_][A-Z0-9_]*.`,
+        );
+      }
+    }
+
+    const resolveArgs = flags.project ? [`--project=${flags.project}`] : [];
+    const { projectId, source } = resolveProject(ctx, resolveArgs);
+
+    // We could pre-fetch the existing var list to warn about unknown
+    // names. Skipping: an extra GET on every unset doubles latency for
+    // the common case where the operator typed the right name. The
+    // backend's op=delete is idempotent.
+    const changes = rest.map((name) => ({ op: "delete", name }));
+    if (!ctx.out.json) {
+      ctx.out.info(
+        `Unsetting ${rest.length} env var${rest.length > 1 ? "s" : ""} on project ${projectId}…`,
+      );
+    }
+    await ctx.api.updateProjectEnvVars(projectId, changes);
+
+    ctx.out.result(
+      {
+        projectId,
+        projectSource: source,
+        deleted: rest.length,
+        names: rest,
+      },
+      (_d, { stdout }) => {
+        for (const name of rest) {
+          stdout.write(`${colors.red("-")} ${colors.bold(name)}\n`);
+        }
+        stdout.write(
+          colors.dim(
+            "Existing deployments keep their cached value until they're recreated.\n",
+          ),
+        );
+      },
+    );
+  },
+};

package/lib/commands/list.js

@@ -0,0 +1,186 @@
+// `synapse list [deployments|projects|teams]` — read-only catalog
+// dumper. Single-arg subcommand that mirrors what you'd see in the
+// dashboard, but scriptable (every subcommand supports --json).
+//
+// Resolution rules:
+//   - `list teams`        → no flag needed (always lists the operator's teams)
+//   - `list projects`     → uses linked team OR --team=<slug|id>
+//   - `list deployments`  → uses linked project OR --project=<id>
+
+const colors = require("../colors");
+const { extractTeamFlag, extractProjectFlag } = require("./_resource");
+
+const KINDS = ["deployments", "projects", "teams"];
+
+async function listTeams(ctx) {
+  const teams = await ctx.api.teams();
+  ctx.out.result(
+    { kind: "teams", count: teams.length, teams },
+    (_d, { stdout }) => {
+      if (teams.length === 0) {
+        stdout.write(colors.dim("(no teams — create one in the dashboard)\n"));
+        return;
+      }
+      ctx.out.table(
+        teams.map((t) => ({
+          name: colors.bold(t.name || t.slug || t.id),
+          slug: t.slug || colors.dim("?"),
+          id: colors.dim(t.id),
+        })),
+        [
+          { key: "name", header: "NAME" },
+          { key: "slug", header: "SLUG" },
+          { key: "id", header: "ID" },
+        ],
+      );
+    },
+  );
+}
+
+async function listProjects(ctx, args) {
+  const { teamRef: explicit, rest } = extractTeamFlag(args);
+  if (rest.length > 0) {
+    throw new Error(
+      `Unexpected positional: ${rest[0]}. Usage: synapse list projects [--team=<slug|id>]`,
+    );
+  }
+  // Linked-project fallback uses ctx.projectConfig.team.slug.
+  let teamRef = explicit;
+  let source = "flag";
+  if (!teamRef) {
+    const linked = ctx.projectConfig;
+    if (linked && linked.team && (linked.team.slug || linked.team.id)) {
+      teamRef = linked.team.slug || linked.team.id;
+      source = "linked";
+    }
+  }
+  if (!teamRef) {
+    throw new Error(
+      "No linked team. Pass --team=<slug|id> or run `synapse select` first.",
+    );
+  }
+  const projects = await ctx.api.projects(teamRef);
+  ctx.out.result(
+    { kind: "projects", team: teamRef, teamSource: source, count: projects.length, projects },
+    (_d, { stdout }) => {
+      stdout.write(colors.dim(`Team: ${teamRef}\n`));
+      if (projects.length === 0) {
+        stdout.write(colors.dim("(no projects)\n"));
+        return;
+      }
+      ctx.out.table(
+        projects.map((p) => ({
+          name: colors.bold(p.name || p.slug),
+          slug: p.slug || colors.dim("?"),
+          id: colors.dim(p.id),
+        })),
+        [
+          { key: "name", header: "NAME" },
+          { key: "slug", header: "SLUG" },
+          { key: "id", header: "ID" },
+        ],
+      );
+    },
+  );
+}
+
+async function listDeployments(ctx, args) {
+  const { projectId: explicit, rest } = extractProjectFlag(args);
+  if (rest.length > 0) {
+    throw new Error(
+      `Unexpected positional: ${rest[0]}. Usage: synapse list deployments [--project=<id>]`,
+    );
+  }
+  let projectId = explicit;
+  let source = "flag";
+  if (!projectId) {
+    const linked = ctx.projectConfig;
+    if (linked && linked.project && linked.project.id) {
+      projectId = linked.project.id;
+      source = "linked";
+    }
+  }
+  if (!projectId) {
+    throw new Error(
+      "No linked project. Pass --project=<id> or run `synapse select` first.",
+    );
+  }
+  const deployments = await ctx.api.deployments(projectId);
+  ctx.out.result(
+    { kind: "deployments", projectId, projectSource: source, count: deployments.length, deployments },
+    (_d, { stdout }) => {
+      stdout.write(colors.dim(`Project: ${projectId}\n`));
+      if (deployments.length === 0) {
+        stdout.write(colors.dim("(no deployments — create one with `synapse deployment create`)\n"));
+        return;
+      }
+      ctx.out.table(
+        deployments.map((d) => ({
+          name: colors.bold(d.name),
+          type: typeBadge(d.deploymentType || d.type),
+          status: colors.statusBadge(d.status || ""),
+          url: d.deploymentUrl || d.url || colors.dim("(no url)"),
+        })),
+        [
+          { key: "name", header: "NAME" },
+          { key: "type", header: "TYPE" },
+          { key: "status", header: "STATUS" },
+          { key: "url", header: "URL" },
+        ],
+      );
+    },
+  );
+}
+
+function typeBadge(t) {
+  switch (t) {
+    case "prod":
+      return colors.yellow((t || "").toUpperCase());
+    case "dev":
+      return colors.cyan ? colors.cyan(t.toUpperCase()) : t.toUpperCase();
+    case "preview":
+      return colors.dim((t || "").toUpperCase());
+    default:
+      return t ? colors.dim(t) : "";
+  }
+}
+
+module.exports = {
+  name: "list",
+  summary: "List teams, projects, or deployments visible to your session.",
+  usage: "synapse list <deployments|projects|teams> [--project=<id>] [--team=<slug>] [--json]",
+  description: `Catalogs the resource of the chosen kind. All subcommands support --json for scripting.
+
+Resource resolution:
+  list teams        always lists every team you're a member of
+  list projects     uses the linked team if no --team flag
+  list deployments  uses the linked project if no --project flag
+
+Examples:
+  synapse list teams
+  synapse list projects --team=amageia
+  synapse list deployments --project=00000000-0000-0000-0000-000000000000
+  synapse list deployments --json | jq '.deployments[] | .name'`,
+
+  // Exports for tests.
+  KINDS,
+  listTeams,
+  listProjects,
+  listDeployments,
+
+  async run(args, ctx) {
+    const kind = args[0];
+    if (!kind) {
+      throw new Error(`Usage: synapse list <${KINDS.join("|")}>`);
+    }
+    if (!KINDS.includes(kind)) {
+      throw new Error(
+        `Unknown list kind: ${kind}. Try: ${KINDS.join(" | ")}.`,
+      );
+    }
+    const rest = args.slice(1);
+    if (kind === "teams") return listTeams(ctx);
+    if (kind === "projects") return listProjects(ctx, rest);
+    return listDeployments(ctx, rest);
+  },
+};

package/lib/prompts.js

@@ -187,6 +187,55 @@ async function choose(label, choices, {
   }
 }
 
+// typedConfirm prompts the user to literally re-type a string (typically
+// the name of a resource about to be destroyed) before proceeding. Match
+// is case-sensitive and exact — `--yes` does NOT bypass this prompt,
+// only an explicit pre-supplied `typed` answer does (for non-interactive
+// CI where the operator already scripted the confirmation).
+//
+// Why we need this in addition to `confirm`: y/n prompts get muscle-
+// memory-yes'd. Typing the literal name of a prod deployment makes the
+// operator look at what they're deleting one more time. Mirrors the
+// dashboard's `delete-deployment` flow shipped in v1.7.2.
+async function typedConfirm(label, expected, {
+  input = process.stdin,
+  output = process.stderr,
+  typed = null,
+  maxAttempts = 3,
+} = {}) {
+  if (typeof expected !== "string" || expected === "") {
+    throw new Error("typedConfirm requires a non-empty `expected` string");
+  }
+  // Non-interactive shortcut: caller pre-supplied the typed string via
+  // a flag (`--confirm=<name>`). We still require exact match; passing
+  // the wrong value should NOT proceed even if the caller meant well.
+  if (typed !== null) {
+    return typed === expected;
+  }
+  if (!input.isTTY) {
+    throw new Error(
+      `Refusing to ${label} without a TTY. Re-run with --confirm=${expected} to confirm non-interactively.`,
+    );
+  }
+  const rl = readline.createInterface({ input, output });
+  try {
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+      const raw = await new Promise((resolve) =>
+        rl.question(`Type ${expected} to confirm ${label}: `, resolve),
+      );
+      const answer = raw.trim();
+      if (answer === expected) return true;
+      if (answer === "" || answer.toLowerCase() === "n" || answer.toLowerCase() === "no") {
+        return false;
+      }
+      output.write(`Doesn't match. Type the exact name "${expected}" or press Enter to cancel.\n`);
+    }
+    return false;
+  } finally {
+    rl.close();
+  }
+}
+
 module.exports = {
   BACK,
   ask,
@@ -195,4 +244,5 @@ module.exports = {
   choose,
   confirm,
   parseCredentialsInput,
+  typedConfirm,
 };

package/package.json

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