@thebaycloud/cli 1.0.0 → 1.1.0

package/lib/brand.js

@@ -33,7 +33,10 @@ const fs = require("fs");
 const BRAND = "Bay";
 const CLI = "bay";
 const DOMAIN = "thebay.cloud";
-const DEFAULT_URL = "https://app.supersonic.cv";
+// Derived from DOMAIN, which said `thebay.cloud` on the line above while this
+// said `supersonic.cv`. Both answer, so nothing broke — which is exactly why it
+// went unnoticed, and why every `bay` install was talking to the retiring name.
+const DEFAULT_URL = `https://app.${DOMAIN}`;
 
 const NEW_DIR = path.join(os.homedir(), ".bay");
 const OLD_DIR = path.join(os.homedir(), ".supersonic");

package/lib/check.js

@@ -203,7 +203,20 @@ function renderService(s) {
     // has no start command, no health path and no request timeout, and printing
     // the defaults for all three would describe a service that is not deployed.
     if (!s.serviceless) {
-      lines.push(phase("start", s.lane === "container"
+      // Keyed off the AUTHOR's Dockerfile, not off the lane.
+      //
+      // Asking `s.lane === "container"` was right while there were four lanes.
+      // There are two. `container` now means "an image is built and a node runs
+      // it" whether the author committed a Dockerfile or `generateDockerfile`
+      // wrote one FROM THIS `start` COMMAND — so the old condition answered "the
+      // Dockerfile's own CMD" for every non-static service, about a repository
+      // with no Dockerfile in it, hiding a command the config states in plain
+      // text. In the one command whose whole job is to say what will run.
+      //
+      // `s.dockerfile` is the author's file and only ever that; resolve.ts draws
+      // the same line. The `image` phase above already names it, so this line
+      // does not repeat the path.
+      lines.push(phase("start", s.dockerfile
         ? "the Dockerfile's own CMD"
         : s.start || (s.runs.length ? "—  (the web process below)" : "—  (nothing to run: this lane needs one)")));
       // The web process's own health check is what the deploy probes, so it is
@@ -271,7 +284,7 @@ function renderCheck(configFilename, app, problems, warnings) {
       lines.push(head.startsWith("✕") ? head : `✕ ${head}`, ...rest);
     }
     lines.push("");
-    lines.push(`${problems.length} problem${problems.length === 1 ? "" : "s"} — nothing was deployed, and nothing would be.`);
+    lines.push(`${problems.length} problem${problems.length === 1 ? "" : "s"} — nothing was shipped, and nothing would be.`);
   } else {
     lines.push("✓ nothing here fails before the build. No GCP was touched.");
   }

package/lib/confirm.js

@@ -36,7 +36,7 @@ function deletionRefusal(app, args) {
 
   return [
     `${app} would be deleted, and so would its DATA: the database, the storage`,
-    "bucket, the images and the deploy history all go with it.",
+    "bucket, the images and the ship history all go with it.",
     "",
     "This cannot be undone, and there is no prompt to say yes to — run",
     `  bay delete ${app} --yes`,

package/lib/draft.js

@@ -478,7 +478,7 @@ function renderDraft(configFilename, config, unknowns) {
   // confidence answer. Presenting its output as a finding rather than a draft is
   // how that answer became a deploy.
   lines.push("This is a draft, from a detector that has been confidently wrong before.");
-  lines.push(`Read it, fix what is wrong, then: supersonic check`);
+  lines.push(`Read it, fix what is wrong, then: bay check`);
   return lines;
 }
 

package/lib/home.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * Where the session lives, and what the variables are called, across a rename.
+ *
+ * Both answers changed at once — `~/.supersonic` became `~/.bay`, `SUPERSONIC_*`
+ * became `BAY_*` — and both have the same failure mode if they change carelessly:
+ * the CLI comes up signed out. Not broken, not erroring; signed out, with a
+ * perfectly good token sitting in a file it stopped looking at, and an agent
+ * mid-task being told to open a browser.
+ *
+ * Pure, and taking the home directory and an existence check as arguments, so
+ * the migration can be tested without touching anyone's real home.
+ */
+
+/**
+ * The config directory: the new name if it is there, the old name if IT is, the
+ * new name otherwise.
+ *
+ * Deliberately not "read both and merge". Two files that disagree about which
+ * account you are would be resolved by whichever line ran first, and the symptom
+ * — deploying to the wrong account — is one nobody would trace back to here. One
+ * directory wins outright, and an existing user keeps writing to the file they
+ * already have.
+ */
+function configDirIn(home, exists, join) {
+  const next = join(home, ".bay");
+  const prev = join(home, ".supersonic");
+  if (exists(next)) return next;
+  if (exists(prev)) return prev;
+  return next;
+}
+
+/**
+ * `BAY_<NAME>`, falling back to `SUPERSONIC_<NAME>`.
+ *
+ * The new name wins when both are set: somebody who exported both is midway
+ * through a migration, and the value they added last is the one they mean. An
+ * empty string is treated as unset, which is what a shell gives you for an
+ * exported-but-never-assigned variable.
+ */
+function envVarFrom(env, name) {
+  return (env["BAY_" + name] || env["SUPERSONIC_" + name] || "").trim();
+}
+
+module.exports = { configDirIn, envVarFrom };

package/lib/resolver.js

@@ -11,8 +11,8 @@
  *
  * Loaded lazily and through a named function rather than at require() time: the
  * bundle is generated, an old global install can be missing it, and a missing
- * bundle must fail `supersonic check` with a sentence naming the fix rather than
- * crashing `supersonic logs`, which does not use it at all.
+ * bundle must fail `bay check` with a sentence naming the fix rather than
+ * crashing `bay logs`, which does not use it at all.
  */
 const path = require("node:path");
 
@@ -37,7 +37,7 @@ function resolver() {
  * The stack detector, as the async `Detect` that inferAppConfig expects.
  *
  * Synchronous in the CLI — there is one process, one repo, and nothing else
- * waiting on the event loop. The control plane spawns the deploy-agent as a
+ * waiting on the event loop. The control plane spawns the detector as a
  * subprocess for the same job, which is why the interface is a promise at all;
  * matching the interface rather than the transport is what lets both callers
  * share inferAppConfig unchanged.

package/lib/rows.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * Query results as a table a terminal can hold.
+ *
+ * `bay db <app> <table>` returns real production rows, and a row is not a
+ * shape this CLI controls: one column is an id, the next is a 4KB blob of JSON,
+ * and printing them raw turns a 12-row answer into four screens of wrapped text
+ * with no visible columns at all. So every cell is flattened to one line and
+ * clipped, and the width is the widest cell that survived.
+ *
+ * Clipping is marked with `…` rather than being silent. A truncated value that
+ * looks whole is worse than no value: it is the one a person copies.
+ *
+ * `--json` exists for everything this drops. That is the contract — this is the
+ * human reading, `--json` is the data.
+ */
+
+/** null and undefined are not the string "null" — they are the empty cell. */
+function cell(v, max) {
+  if (v === null || v === undefined) return "";
+  const s = typeof v === "object" ? JSON.stringify(v) : String(v);
+  // Tabs and newlines inside a value would break the alignment of every row
+  // after them, so they become a single space before anything is measured.
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > max ? flat.slice(0, max - 1) + "…" : flat;
+}
+
+/**
+ * @param {string[]} columns
+ * @param {object[]} rows
+ * @param {{max?: number}} [opts]  max characters per cell (default 40)
+ * @returns {string[]} lines: a header, a rule, then one line per row
+ */
+function renderTable(columns, rows, opts = {}) {
+  const max = opts.max ?? 40;
+  const cols = columns || [];
+  if (!cols.length) return [];
+
+  const body = (rows || []).map((r) =>
+    // Arrays as well as objects: `SELECT` results arrive keyed by column name,
+    // but a caller holding tuples should not have to convert them first.
+    cols.map((c, i) => cell(Array.isArray(r) ? r[i] : r?.[c], max))
+  );
+
+  const width = cols.map((c, i) =>
+    Math.max(cell(c, max).length, ...body.map((r) => r[i].length), 1)
+  );
+
+  // The last column is not padded. Trailing spaces are invisible until somebody
+  // pipes this into a diff, and every line would carry them.
+  const line = (parts) => parts.map((p, i) => (i === parts.length - 1 ? p : p.padEnd(width[i]))).join("  ").trimEnd();
+
+  return [
+    line(cols.map((c) => cell(c, max))),
+    line(width.map((w) => "─".repeat(w))),
+    ...body.map(line),
+  ];
+}
+
+module.exports = { renderTable, cell };

package/lib/share-args.js

@@ -0,0 +1,93 @@
+"use strict";
+
+/**
+ * What `bay share` was asked to do, decided before anything is sent.
+ *
+ * Access is the one command in this CLI where a misread argument does damage
+ * that is not visible afterwards: `share app add acme.com` meant as "everyone at
+ * my company" and read as an email address would fail loudly, which is fine —
+ * but read the other way round it would let a whole domain into an app the
+ * owner meant to send to one person, and nothing on screen would look wrong.
+ * So the reading is a pure function with tests, and the network call is what
+ * happens after it.
+ *
+ * The two audiences are told apart by shape, not by a flag:
+ *
+ *   ada@acme.com   an address        -> one person, invited by email
+ *   @acme.com      a rule            -> everyone whose address ends in it
+ *   acme.com       the same rule     -> the @ is how people write it, not a requirement
+ *
+ * A bare word with no dot is neither, and is refused rather than guessed at.
+ */
+
+/** The three visibilities the control plane accepts, in the order they widen. */
+const VISIBILITIES = ["private", "shared", "public"];
+
+/**
+ * @param {string} who
+ * @returns {{audience: "email"|"domain", value: string}|null}
+ */
+function audienceOf(who) {
+  const w = String(who ?? "").trim().toLowerCase();
+  if (!w) return null;
+
+  // An @ anywhere but the front makes it an address. RFC 5321 caps a mailbox at
+  // 254 characters; past that it is not an address that could ever be delivered
+  // to, and the server refuses it — better said here, where the reason fits on
+  // one line.
+  if (w.includes("@") && !w.startsWith("@")) {
+    if (w.length > 254 || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(w)) return null;
+    return { audience: "email", value: w };
+  }
+
+  const domain = w.replace(/^@/, "");
+  if (!/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(domain)) return null;
+  return { audience: "domain", value: domain };
+}
+
+/**
+ * @param {string[]} rest  the arguments after the app name
+ * @returns {{kind: "show"}
+ *          |{kind: "visibility", visibility: string}
+ *          |{kind: "add"|"remove", audience: "email"|"domain", value: string}
+ *          |{kind: "error", why: string}}
+ */
+function parseShare(rest) {
+  const [verb, ...targets] = (rest || []).filter((t) => t !== undefined && t !== null);
+  if (!verb) return { kind: "show" };
+
+  const v = String(verb).trim().toLowerCase();
+  if (VISIBILITIES.includes(v)) return { kind: "visibility", visibility: v };
+
+  if (v === "add" || v === "remove" || v === "rm") {
+    const kind = v === "rm" ? "remove" : v;
+    if (!targets.length) {
+      return { kind: "error", why: `who? usage: bay share <app> ${kind} <email|@domain>` };
+    }
+    const audience = audienceOf(targets[0]);
+    if (!audience) {
+      return {
+        kind: "error",
+        why: `"${targets[0]}" is neither an email address nor a domain — write ada@acme.com for one person, or @acme.com for everyone there`,
+      };
+    }
+    return { kind, ...audience };
+  }
+
+  return {
+    kind: "error",
+    why: `unknown: share ${v}\nusage: bay share <app> [private|shared|public | add <email|@domain> | remove <email|@domain>]`,
+  };
+}
+
+/**
+ * The request body for an add/remove, in the shape the control plane's share
+ * route reads. Kept beside the parser because the four field names — addEmail,
+ * addDomain, removeEmail, removeDomain — are the only thing connecting the two.
+ */
+function shareBody(action) {
+  const suffix = action.audience === "email" ? "Email" : "Domain";
+  return { [action.kind + suffix]: action.value };
+}
+
+module.exports = { parseShare, audienceOf, shareBody, VISIBILITIES };

package/lib/who.js

@@ -2,9 +2,10 @@
 /**
  * Who is shipping, as declared — never as inferred.
  *
- * An agent sets BAY_WHO=agent (SUPERSONIC_WHO still works). Nothing else is consulted: a TTY check
- * would call CI an agent, and the platform would then draw a figure that was
- * never there. The absence of a name is a fact; a wrong name is a lie.
+ * An agent sets BAY_WHO=agent (SUPERSONIC_WHO is still read, because it is what
+ * the agent prompts written before the rename say). Nothing else is consulted: a
+ * TTY check would call CI an agent, and the platform would then draw a figure
+ * that was never there. The absence of a name is a fact; a wrong name is a lie.
  */
 function whoHeader(env) {
   const v = String(env.BAY_WHO || env.SUPERSONIC_WHO || "").trim().toLowerCase();

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@thebaycloud/cli",
-  "version": "1.0.0",
-  "description": "Deploy & debug Bay apps from your coding agent — the agent-native CLI.",
+  "version": "1.1.0",
+  "description": "Ship & debug Bay apps from your coding agent \u2014 the agent-native CLI.",
   "bin": {
-    "bay": "index.js",
-    "supersonic": "index.js"
+    "bay": "./index.js",
+    "supersonic": "./index.js"
   },
   "type": "commonjs",
   "engines": {
@@ -21,16 +21,16 @@
     "bundle-detector": "node scripts/bundle-detector.mjs",
     "bundle-resolver": "node scripts/bundle-resolver.mjs",
     "bundle": "npm run bundle-detector && npm run bundle-resolver",
-    "test": "node --test 'test/**/*.test.js'",
+    "test": "node --test",
     "prepublishOnly": "npm run bundle && npm test"
   },
   "keywords": [
     "deploy",
     "cloud",
     "gcp",
+    "cloud-run",
     "vibecoding",
-    "bay",
-    "coding-agent"
+    "bay"
   ],
   "homepage": "https://thebay.cloud",
   "repository": {
@@ -39,10 +39,10 @@
     "directory": "packages/cli"
   },
   "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/The-Red-Onion/supersonic/issues"
-  },
   "publishConfig": {
     "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/thebaycloud/bay/issues"
   }
 }

package/vendor/README.md

@@ -1,6 +1,6 @@
 Generated. Do not edit — `npm run bundle` rebuilds all of it.
 
-- detector.js — scripts/bundle-detector.mjs, from services/deploy-agent
+- detector.js — scripts/bundle-detector.mjs, from packages/detector
 - resolve.js  — scripts/bundle-resolver.mjs, from apps/web/lib
 - inputs.json — every repository file esbuild inlined into each bundle, from its metafile.
                 test/vendor.test.js hashes these to prove the bundles are not stale.

package/vendor/detector.js

@@ -1,4 +1,4 @@
-// supersonic-vendor-stamp 541ed09e927ae777
+// supersonic-vendor-stamp 90d7b95c32307760
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -349,7 +349,7 @@ function provisionPlan(s) {
   plan.push("Apply security baseline (secret scan, rate limits, WAF)");
   plan.push("Enable daily backups");
   if (s.secretsNeeded.length) plan.push(`Ask user for secrets: ${s.secretsNeeded.join(", ")}`);
-  plan.push(`Deploy to Cloud Run on :${s.port} \u2192 <slug>.supersonic.cv`);
+  plan.push(`Deploy to Cloud Run on :${s.port} \u2192 <slug>.thebay.cloud`);
   return plan;
 }
 function cloneToTemp(url) {

package/vendor/inputs.json

@@ -1,13 +1,14 @@
 {
   "detector.js": [
     "apps/web/lib/plan-deps.ts",
-    "services/deploy-agent/src/index.ts"
+    "packages/detector/src/index.ts"
   ],
   "resolve.js": [
     "apps/web/lib/app-config.ts",
     "apps/web/lib/db-address.ts",
     "apps/web/lib/detect.ts",
     "apps/web/lib/dockerfile-context.ts",
+    "apps/web/lib/env-owner.ts",
     "apps/web/lib/infer-services.ts",
     "apps/web/lib/lanes.ts",
     "apps/web/lib/plan-deps.ts",

package/vendor/resolve.js

@@ -1,4 +1,4 @@
-// supersonic-vendor-stamp d638cb7c23598653
+// supersonic-vendor-stamp 60282bc736f6efbe
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -118,15 +118,17 @@ function withScale(over) {
   return { ...DEFAULT_SCALE, ...declared };
 }
 
+// lib/env-owner.ts
+var ALWAYS_OWNED_PREFIXES = [/^BAY_/, /^SUPERSONIC_/];
+var ALWAYS_OWNED_EXACT = /* @__PURE__ */ new Set(["PORT"]);
+var DATABASE_OWNED_PREFIXES = [/^POSTGRES_/, /^PG/, /^DB_/];
+var DATABASE_OWNED_EXACT = new Set(databaseEnvNames());
+
 // lib/app-config.ts
 var CONFIG_FILENAME = "supersonic.json";
 var ConfigError = class extends Error {
 };
 var LANGUAGES = /* @__PURE__ */ new Set(["node", "python", "static", "other"]);
-var ALWAYS_OWNED_PREFIXES = [/^SUPERSONIC_/];
-var ALWAYS_OWNED_EXACT = /* @__PURE__ */ new Set(["PORT"]);
-var DATABASE_OWNED_PREFIXES = [/^POSTGRES_/, /^PG/, /^DB_/];
-var DATABASE_OWNED_EXACT = new Set(databaseEnvNames());
 function platformOwned(name, database) {
   if (ALWAYS_OWNED_EXACT.has(name) || ALWAYS_OWNED_PREFIXES.some((re) => re.test(name))) return true;
   if (database?.provider !== "managed") return false;
@@ -576,14 +578,14 @@ function runtimeMismatch(manifests) {
   if (py) {
     const need = lowestAccepted(py);
     if (need && below(RUNTIME_VERSIONS.python, need)) {
-      return `this app needs Python ${py} and the runner has ${RUNTIME_VERSIONS.python} \u2014 widen requires-python in pyproject.toml to accept ${RUNTIME_VERSIONS.python}, or wait for the runner to move. Nothing in the code can fix this one.`;
+      return `this app needs Python ${py} and the platform has ${RUNTIME_VERSIONS.python} \u2014 widen requires-python in pyproject.toml to accept ${RUNTIME_VERSIONS.python}, or wait for the platform to move. Nothing in the code can fix this one.`;
     }
   }
   const engines = manifests.packageJson?.engines?.node;
   if (engines) {
     const need = lowestAccepted(engines);
     if (need && below(RUNTIME_VERSIONS.node, need)) {
-      return `this app needs Node ${engines} and the runner has ${RUNTIME_VERSIONS.node} \u2014 widen engines.node in package.json to accept ${RUNTIME_VERSIONS.node}, or wait for the runner to move. Nothing in the code can fix this one.`;
+      return `this app needs Node ${engines} and the platform has ${RUNTIME_VERSIONS.node} \u2014 widen engines.node in package.json to accept ${RUNTIME_VERSIONS.node}, or wait for the platform to move. Nothing in the code can fix this one.`;
     }
   }
   return null;