@rebasepro/cli 0.13.0 → 0.13.1-canary.g1822133

package/dist/commands/init.d.ts

@@ -68,4 +68,71 @@ export declare function formatCdTarget(cwd: string, targetDirectory: string): st
  * triggering the non-TTY error. */
 export declare function printInitHelp(): void;
 export declare function createRebaseApp(rawArgs: string[]): Promise<void>;
+/** The flags `rebase init` takes. */
+export declare const INIT_FLAGS: {
+    readonly "--git": BooleanConstructor;
+    readonly "--install": BooleanConstructor;
+    readonly "--database-url": StringConstructor;
+    readonly "--introspect": BooleanConstructor;
+    readonly "--template": StringConstructor;
+    readonly "--headless": BooleanConstructor;
+    readonly "--project": StringConstructor;
+    readonly "--setup-key": StringConstructor;
+    readonly "--yes": BooleanConstructor;
+    readonly "-g": "--git";
+    readonly "-i": "--install";
+    readonly "-t": "--template";
+    readonly "-y": "--yes";
+};
+/**
+ * Whether `port` is free — on the wildcard address *and* on both loopback addresses.
+ *
+ * All three, because on macOS/BSD a successful bind does not mean the port is
+ * unused. Sockets carry `SO_REUSEADDR` (Node sets it), under which a wildcard
+ * bind and a specific-address bind on the same port do not conflict — in either
+ * direction. So each probe alone has a blind spot, and they are different ones:
+ *
+ * - **Wildcard only** (what this used to do) misses a server bound to
+ *   `127.0.0.1` and `[::1]` — a Homebrew or Postgres.app install, i.e. most
+ *   developer machines. 5432 was reported free while it was already serving
+ *   another project's database. Docker then published `*:5432` for the same
+ *   reason and the container started cleanly, with no "port already allocated"
+ *   error anywhere to hint at the collision. `DATABASE_URL` pointed at
+ *   `localhost:5432`, `localhost` resolves to `::1` first, and every command
+ *   reported success while reading and writing the *pre-existing* database — a
+ *   `db push` would have created tables, roles and RLS policies inside it.
+ *
+ * - **Loopback only** misses the opposite case: Docker Desktop publishes a
+ *   container's port on `*`, and a specific-address bind succeeds right past it.
+ *   That port is free to probe and unusable to publish, so `docker compose up -d
+ *   db` fails on "Bind for 0.0.0.0:PORT failed: port is already allocated" —
+ *   loudly, but only after the project has been generated around the bad port.
+ *
+ * Requiring all three costs three sockets and leaves neither gap. The wildcard
+ * bind is the one the container itself has to make; the loopback binds are the
+ * addresses `DATABASE_URL` will actually name.
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * The runtime image tag to pin, given the version of the CLI doing the scaffolding.
+ *
+ * Only a stable release publishes `rebasepro/server` — a multi-arch build on
+ * every push to main would cost minutes per commit for an image nobody pulls.
+ * So pinning a prerelease CLI's own version writes a tag that cannot exist, and
+ * `docker compose up` fails on `manifest unknown`, which is the same dead end
+ * as the missing-repository bug this pinning was added to prevent.
+ *
+ * A prerelease therefore falls back to `latest`, which is correct rather than
+ * merely available: a bundle's manifest declares the runtime range it needs
+ * (`^1`), the image supplies only `@rebasepro/server`, and the framework a
+ * bundle runs is installed from its own `deps.declared` at boot. The current
+ * stable runtime boots a canary bundle by design.
+ *
+ * A floating tag is a real cost — it is what pinning exists to avoid — so say
+ * so in the file rather than leaving a reader to discover it.
+ */
+export declare function resolveRuntimeImageTag(cliVersion: string): {
+    tag: string;
+    note?: string;
+};
 export declare function configureEnvFile(targetDirectory: string, databaseUrl?: string): Promise<void>;

package/dist/commands/skills.d.ts

@@ -1 +1,82 @@
+/**
+ * Supported agent environments and their target directories.
+ *
+ * `flatLayout` says where the installed rule file sits relative to the skill's
+ * own assets. A subdirectory layout writes `<skill>/SKILL.md`, so a link the
+ * skill spells `references/x.md` resolves as written; a flat layout writes
+ * `<skill>.md` one level up, so those links have to be re-pointed at the
+ * per-skill asset directory. See `rewriteAssetLinks`.
+ */
+declare const AGENTS: {
+    readonly cursor: {
+        readonly label: "Cursor";
+        readonly detectDir: ".cursor";
+        readonly targetDir: ".cursor/rules";
+        readonly flatLayout: true;
+        /** Cursor uses .mdc files (Markdown with Context). */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+    readonly claude: {
+        readonly label: "Claude Code";
+        readonly detectDir: ".claude";
+        readonly targetDir: ".claude/skills";
+        readonly flatLayout: false;
+        /** Claude Code uses the standard SKILL.md format in subdirectories. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+    readonly windsurf: {
+        readonly label: "Windsurf";
+        readonly detectDir: ".windsurf";
+        readonly targetDir: ".windsurf/rules";
+        readonly flatLayout: true;
+        /** Windsurf uses plain .md files. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+    readonly gemini: {
+        readonly label: "Gemini CLI / Antigravity";
+        readonly detectDir: ".agents";
+        readonly targetDir: ".agents/skills";
+        readonly flatLayout: false;
+        /** Gemini uses the standard SKILL.md format in subdirectories. */
+        readonly transformFile: (skillName: string, content: string) => {
+            fileName: string;
+            content: string;
+        };
+    };
+};
+type AgentKey = keyof typeof AGENTS;
+export interface LoadedSkill {
+    name: string;
+    /** Absolute path of the skill's source directory. */
+    dir: string;
+    content: string;
+    /** Every file the skill ships besides SKILL.md, relative to `dir`. */
+    assets: string[];
+}
+/** Read all skill directories and return their names, content and assets. */
+export declare function loadSkills(skillsDir: string): LoadedSkill[];
+/**
+ * Re-point a skill's own asset links at the per-skill subdirectory, for the
+ * agents whose rule file does not live in it.
+ *
+ * Only paths that name a file the skill actually ships are rewritten, and only
+ * where they start a path segment — so prose that happens to contain the same
+ * words is left alone.
+ */
+export declare function rewriteAssetLinks(content: string, assets: string[], skillName: string): string;
+/** Install skills for a specific agent into the project directory. */
+export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string): {
+    skills: number;
+    assets: number;
+};
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+export {};

package/dist/fold-static.d.ts

@@ -62,6 +62,53 @@ export declare function foldableApps(manifest: FoldableManifest): {
  * evidence of a misbuild.
  */
 export declare function assertBuiltForPath(indexHtml: string, basePath: string, appName: string): void;
+/**
+ * The environment every static app is built with, wherever that build is driven from.
+ *
+ * Shared because there are two drivers — `foldFrontendIntoBundle` here, and
+ * `buildAssetApp` in `build.ts` for a standalone `type: "static"` app — and they
+ * had already drifted: the path variables were duplicated into both, so a fix
+ * applied to one shipped a bundle built the old way from the other. One function
+ * makes that impossible rather than merely unlikely.
+ *
+ * ## REBASE_APP_*
+ *
+ * The declared path is a build-time input, not only a serving concern: Vite
+ * reads `base` from REBASE_APP_BASE, and the trailing slash is that field's
+ * convention. See `assertBuiltForPath`.
+ *
+ * ## NODE_ENV
+ *
+ * A built app is a production artifact by construction, so build it as one. Not
+ * a formality: the scaffold's `.env` carries `NODE_ENV=development` for the dev
+ * backend, and Vite's `loadEnv` promotes a `NODE_ENV` found in an env file into
+ * the build unless the environment already sets one. So `rebase build` and
+ * `rebase cloud deploy` shipped a *development* bundle — `import.meta.env.DEV
+ * === true`, development React, dev-only branches live — from commands whose
+ * whole purpose is to produce something deployable. Setting it here is what
+ * closes it: Vite consults the env file's NODE_ENV only when `process.env`
+ * has none.
+ *
+ * ## VITE_API_URL
+ *
+ * An app served by the backend it talks to has its API on its own origin by
+ * construction, so a baked-in absolute URL can only be wrong. It was: that same
+ * `.env` carries `VITE_API_URL=http://localhost:3001` and
+ * `frontend/vite.config.ts` reads the project root via `envDir: ".."`, so a
+ * stock deploy shipped a site whose every request went to whoever ran the build
+ * — passing every server-side health check on the way out. Blanking it here
+ * fixes the bundle even for a project whose `.env` predates the `init` fix, or
+ * was written by hand. Empty is the right value rather than a missing one: the
+ * client falls back to `window.location.origin`, which keeps working when a
+ * custom domain is added.
+ *
+ * Vite prioritises `process.env.VITE_*` over `.env` files, so an explicit
+ * `VITE_API_URL=https://api.example.com rebase cloud deploy` still wins — the
+ * cross-origin escape hatch stays open, it just has to be deliberate. Nothing on
+ * this path loads the project `.env` into `process.env`, so a value inherited
+ * here really was set by the caller.
+ */
+export declare function staticBuildEnv(appPath: string, appName: string): Record<string, string>;
 /**
  * Build the project's static apps and fold them into the backend bundle.
  *