@iann29/synapse 1.7.0 → 1.8.1

package/lib/commands/status.js

@@ -0,0 +1,173 @@
+// `synapse status` — quick summary of every deployment in the linked
+// project. Status icon + type badge + URL + URL form chip. Mirrors
+// what the dashboard's project page shows, in 1 terminal screen.
+//
+// Works without `synapse select` IF --project=<id> is passed. Otherwise
+// reads .synapse/project.json from cwd.
+
+const colors = require("../colors");
+
+// Same heuristic as dashboard/app/embed/[name]/page.tsx:isBrowserReachableURL.
+// We classify the URL form so the operator knows at a glance which
+// deployments are reachable from the browser vs which fall back to
+// the host:port form that needs SYNAPSE_BASE_DOMAIN or a custom domain.
+function urlForm(rawUrl, publicUrl) {
+  if (!rawUrl) return "unknown";
+  let u;
+  try {
+    u = new URL(rawUrl);
+  } catch {
+    return "unknown";
+  }
+  if (u.pathname.startsWith("/d/")) return "path";
+  const STANDARD = new Set(["", "443", "80", "6791"]);
+  if (
+    !STANDARD.has(u.port) &&
+    u.hostname !== "localhost" &&
+    u.hostname !== "127.0.0.1"
+  ) {
+    return "host";
+  }
+  if (!publicUrl) return "custom";
+  try {
+    const pu = new URL(publicUrl);
+    if (u.hostname === pu.hostname) return "custom";
+    if (u.hostname.endsWith("." + pu.hostname)) return "wildcard";
+    return "custom";
+  } catch {
+    return "custom";
+  }
+}
+
+function parseFlags(args) {
+  let projectId = null;
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--project") {
+      projectId = args[i + 1];
+      i += 1;
+    } else if (arg.startsWith("--project=")) {
+      projectId = arg.slice("--project=".length);
+    } else {
+      rest.push(arg);
+    }
+  }
+  return { projectId, rest };
+}
+
+module.exports = {
+  name: "status",
+  summary: "List deployments in the linked project with status + URL form.",
+  usage: "synapse status [--project=<id>] [--json]",
+  description: `Lists every deployment in the linked project (or the project given by --project=<id>) along with its status, URL, and URL form ('custom' / 'wildcard' / 'path' / 'host').
+
+The URL form tells you whether the deployment is reachable from a browser:
+  custom    bound to a custom domain (api.client.com) — reachable
+  wildcard  uses SYNAPSE_BASE_DOMAIN subdomain — reachable
+  path      /d/<name>/* via the proxy — browser-reachable but CLI-broken
+            (the Convex CLI strips paths from base URLs)
+  host      host:port form — NOT reachable from a normal browser
+            (Caddy doesn't TLS-front dynamic ports)
+
+Run \`synapse doctor\` for a deeper health check.`,
+
+  // Re-exports for tests.
+  urlForm,
+  parseFlags,
+
+  async run(args, ctx) {
+    const { projectId: explicitProjectId } = parseFlags(args);
+    let projectId = explicitProjectId;
+    let projectLabel = null;
+    if (!projectId) {
+      const pc = ctx.requireProject();
+      projectId = pc.project.id;
+      projectLabel = pc.project.name || pc.project.slug;
+    }
+
+    const deployments = await ctx.api.deployments(projectId);
+    const baseUrl = ctx.cfg.baseUrl;
+
+    const rows = deployments.map((d) => {
+      const type = d.deploymentType || d.type || "";
+      const url = d.deploymentUrl || d.url || "";
+      return {
+        name: d.name,
+        type,
+        status: d.status,
+        url,
+        urlForm: urlForm(url, baseUrl),
+        isDefault: !!d.isDefault,
+        adopted: !!d.adopted,
+        haEnabled: !!d.haEnabled,
+        replicaCount: d.replicaCount,
+      };
+    });
+
+    ctx.out.result(
+      { projectId, project: projectLabel, deployments: rows },
+      (data, { stdout }) => {
+        if (data.project) {
+          stdout.write(colors.bold(`Project: ${data.project}\n`));
+        }
+        if (rows.length === 0) {
+          stdout.write(colors.dim("(no deployments)\n"));
+          return;
+        }
+        const tag = (form) => {
+          switch (form) {
+            case "custom":
+              return colors.green("custom");
+            case "wildcard":
+              return colors.green("wildcard");
+            case "path":
+              return colors.dim("path");
+            case "host":
+              return colors.red("no-domain");
+            default:
+              return colors.dim("?");
+          }
+        };
+        ctx.out.table(
+          rows.map((r) => ({
+            name: colors.bold(r.name),
+            type: typeBadge(r.type),
+            status: colors.statusBadge(r.status || ""),
+            urlForm: tag(r.urlForm),
+            url: r.url,
+          })),
+          [
+            { key: "name", header: "NAME" },
+            { key: "type", header: "TYPE" },
+            { key: "status", header: "STATUS" },
+            { key: "urlForm", header: "FORM" },
+            { key: "url", header: "URL" },
+          ],
+        );
+        const broken = rows.filter((r) => r.urlForm === "host").length;
+        if (broken > 0) {
+          stdout.write("\n");
+          ctx.out.warn(
+            `${broken} deployment${broken > 1 ? "s" : ""} not browser-reachable — set SYNAPSE_BASE_DOMAIN on the server OR add a custom domain per deployment. Run \`synapse doctor\` for the full diagnosis.`,
+          );
+        }
+      },
+    );
+  },
+};
+
+// Tiny tone helper that mirrors the dashboard's envTone() so colors
+// stay consistent across UI surfaces.
+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) : "";
+  }
+}

package/lib/commands/version.js

@@ -0,0 +1,77 @@
+// `synapse version` — print the CLI's own version, plus the version of
+// the Synapse backend it's logged into (best-effort), plus Node + OS.
+//
+// Designed to be the first thing operators run when reporting a bug —
+// the data here is enough to triage without further questions.
+
+const os = require("node:os");
+const pkg = require("../../package.json");
+
+module.exports = {
+  name: "version",
+  summary: "Show CLI, backend, Node and OS versions.",
+  usage: "synapse version [--json]",
+  description: `Reports:
+  cli       this package's npm version (from package.json)
+  backend   the Synapse instance's version (via /v1/install_status)
+  node      runtime version
+  platform  os + arch
+
+If you're not logged in, backend is reported as null with a reason.
+Output is stable across releases — safe to grep in CI logs.`,
+
+  async run(_args, ctx) {
+    const cliVersion = pkg.version;
+    const node = process.version;
+    const platform = `${os.platform()} ${os.release()} (${process.arch})`;
+
+    let backend = null;
+    let backendError = null;
+    const cfg = ctx.cfgOrNull;
+    if (!cfg || !cfg.baseUrl) {
+      backendError = "not logged in";
+    } else {
+      try {
+        // install_status is public — no auth needed, no refresh races.
+        // Use the unauthenticated SynapseAPI so a 401 on /me/ doesn't
+        // muddy this purely informational call.
+        const { SynapseAPI } = require("../api");
+        const probe = new SynapseAPI({ baseUrl: cfg.baseUrl });
+        const status = await probe.request(
+          "GET",
+          "/v1/install_status",
+          undefined,
+          { auth: false },
+        );
+        backend = { url: cfg.baseUrl, version: status.version, firstRun: status.firstRun };
+      } catch (err) {
+        backendError = err && err.message ? err.message : String(err);
+        backend = { url: cfg.baseUrl, version: null };
+      }
+    }
+
+    const payload = {
+      cli: cliVersion,
+      backend,
+      backendError,
+      node,
+      platform,
+    };
+
+    ctx.out.result(payload, (d, { stdout }) => {
+      const widest = "platform".length;
+      const pad = (k) => k.padEnd(widest);
+      stdout.write(`${pad("cli")}  ${d.cli}\n`);
+      if (d.backend) {
+        const v = d.backend.version ? `${d.backend.version}` : "(unknown)";
+        const reason = d.backendError ? ` — ${d.backendError}` : "";
+        stdout.write(`${pad("backend")}  ${v}${reason}\n`);
+        stdout.write(`${pad("")}  at ${d.backend.url}\n`);
+      } else {
+        stdout.write(`${pad("backend")}  (not logged in)\n`);
+      }
+      stdout.write(`${pad("node")}  ${d.node}\n`);
+      stdout.write(`${pad("platform")}  ${d.platform}\n`);
+    });
+  },
+};

package/lib/commands/whoami.js

@@ -0,0 +1,22 @@
+// `synapse whoami` — confirm the saved session is alive against the
+// backend. Hits /v1/me; if the access token is expired but the
+// refresh token still works, the api proxy silently rotates the
+// bundle transparently before reporting OK.
+
+module.exports = {
+  name: "whoami",
+  summary: "Show the email + URL the saved session is authenticated for.",
+  usage: "synapse whoami",
+  description: `Calls /v1/me/ on the backend. Returns the user's display name + email + the base URL of the Synapse instance. Triggers silent-refresh under the hood if the access token has expired but the refresh token is still good.`,
+
+  async run(_args, ctx) {
+    const me = await ctx.api.me();
+    const email = me.email || me.user?.email || "(unknown email)";
+    const name = me.name || me.user?.name || "";
+    ctx.out.result(
+      { email, name, baseUrl: ctx.cfg.baseUrl },
+      ({ email, name, baseUrl }, { stdout }) =>
+        stdout.write(`${name ? `${name} ` : ""}<${email}> on ${baseUrl}\n`),
+    );
+  },
+};