@rebasepro/cli 0.22.0 → 0.24.0

package/dist/commands/cloud/token-capabilities.d.ts

@@ -0,0 +1,76 @@
+/**
+ * What a Rebase Cloud token may do, named the way a person asks for it.
+ *
+ * A token is a personal API key on the control plane: it acts as the account
+ * that created it, and holds only the scopes it was given. Nobody should have
+ * to know that `rebase cloud deploy` reads the `deployments` collection, uploads
+ * through the `deploy` function and needs `project:deploy` on one project — so
+ * `rebase cloud tokens create --can deploy` and the console's token screen both
+ * ask for a capability, and this module turns capabilities into scopes.
+ *
+ * One map, read by the CLI and by the console. Each capability covers exactly
+ * the control-plane calls its commands make, traced from the commands
+ * themselves and held there by `token-capabilities.test.ts`, which runs them
+ * against a stand-in control plane that refuses everything a token does not
+ * hold:
+ *
+ * - `deploy`   — `rebase cloud deploy` (bundle and source paths, uploads, the
+ *                build follow) and `rebase cloud deployments`.
+ * - `logs`     — `rebase cloud logs` (build, `--follow`, `--runtime`),
+ *                `rebase cloud metrics` and `rebase cloud cron` — whose
+ *                `runtime-token` call is how a token reads the app's own
+ *                cron history.
+ * - `env`      — `rebase cloud env list|set|unset|reveal|pull`.
+ * - `database` — `rebase cloud db list|info|connect`.
+ * - `backups`  — `rebase cloud db backup list|create|status|download` and
+ *                `db pitr status`. Restoring takes `project:restore`, which no
+ *                capability grants: putting old data over a live database is
+ *                for a signed-in person.
+ *
+ * Every project-level scope is narrowed to the one project the token is for
+ * (`project:deploy:<projectId>`). The data and function scopes cannot be: they
+ * name a collection or a function, not a row, and the control plane's
+ * row-level security keeps the token to what its owner can see.
+ *
+ * Deliberately free of imports, so the control plane's console can read the
+ * same file.
+ *
+ * @module
+ */
+/** A capability a token can be given. */
+export type TokenCapability = "deploy" | "logs" | "env" | "database" | "backups";
+/** Every capability, in the order they are offered. */
+export declare const TOKEN_CAPABILITY_NAMES: readonly TokenCapability[];
+/**
+ * Scopes every token holds, whatever it was created for: resolving a project
+ * by its slug, reading the deployment a command follows, the organization a
+ * project belongs to, and the control plane's public description of itself.
+ */
+export declare const ALWAYS_SCOPES: string[];
+/** Each capability: what it lets a token do, and the scopes that does on one project. */
+export declare const TOKEN_CAPABILITIES: Record<TokenCapability, {
+    label: string;
+    scopes: (projectId: string) => string[];
+}>;
+/** Whether a word names a capability. */
+export declare function isTokenCapability(value: string): value is TokenCapability;
+/**
+ * The scopes a token for `capabilities` on one project holds: {@link ALWAYS_SCOPES}
+ * first, then each capability's, each scope once.
+ *
+ * Throws on a project id a scope cannot carry — empty, or with whitespace — and
+ * on an unknown capability, both of which are a caller's mistake rather than
+ * something to mint a token from.
+ */
+export declare function scopesForCapabilities(projectId: string, capabilities: readonly TokenCapability[]): string[];
+/**
+ * Read a token's scopes back as capabilities: the projects its project scopes
+ * name, and, for each, the capabilities it holds every scope of.
+ *
+ * For showing a token — `rebase cloud tokens list`, `rebase cloud whoami` — so
+ * a list of fifteen scope strings reads as "deploy, logs on <project>".
+ */
+export declare function capabilitiesInScopes(scopes: readonly string[]): Array<{
+    projectId: string;
+    capabilities: TokenCapability[];
+}>;

package/dist/commands/cloud/tokens.d.ts

@@ -0,0 +1,23 @@
+import { type TokenCapability } from "./token-capabilities.js";
+/** Every action the group dispatches. */
+export declare const TOKENS_ACTIONS: readonly ["list", "create", "revoke"];
+/** What `rebase cloud tokens create` parses, beside the global flags (`--project` among them). */
+export declare const CREATE_TOKEN_FLAGS: {
+    "--can": [StringConstructor];
+    "--name": StringConstructor;
+    "--expires-in": StringConstructor;
+};
+export declare function tokensCommand(action: string | undefined, rawArgs: string[]): Promise<void>;
+/**
+ * The capabilities `--can` names, comma-separated or repeated, each once.
+ *
+ * Exported so its tests can drive it without a session.
+ */
+export declare function parseCapabilities(values: readonly string[] | undefined): TokenCapability[];
+/**
+ * `--expires-in <days>` as an ISO timestamp, or null for a token that does not
+ * expire.
+ *
+ * Exported so its tests can drive it without a session.
+ */
+export declare function resolveTokenExpiry(value: string | undefined, now?: Date): string | null;

package/dist/commands/db.d.ts

@@ -17,6 +17,20 @@ import { type DevDatabase } from "../dev-db/resolve.js";
  * it open.
  */
 export declare function databaseUrlOf(prepared: Pick<PreparedDatabase, "env" | "database">, envFile: Record<string, string>): string | undefined;
+/**
+ * The flags whose value is a local path, on every line the CLI relays.
+ *
+ * All three spellings of the destination, because the driver accepts all
+ * three: `backup-cli.ts` maps `--output` and `-o` onto `--out`, and `rebase db
+ * backup --help` advertises `--output` as an alias. Only `--out` and `-o` were
+ * absolutised once, so the one spelling the help page names was the one that
+ * landed in `backend/` — and the success line still echoed the path as typed.
+ *
+ * And `--collections`, which was not absolutised at all: from the project root,
+ * `rebase schema generate --collections ./config/collections` was "not found",
+ * while the same spelling worked for `generate-sdk`. See `utils/path-flags.ts`.
+ */
+export declare const LOCAL_PATH_FLAGS: readonly string[];
 /**
  * Rewrite local path arguments so they mean what the user typed.
  *
@@ -31,7 +45,7 @@ export declare function databaseUrlOf(prepared: Pick<PreparedDatabase, "env" | "
  * Absolutising here rather than inside the plugin keeps the fix where the cwd
  * is actually changed, and leaves the plugin usable on its own terms.
  */
-export declare function absolutizeLocalPathArgs(args: string[], cwd: string): string[];
+export declare function absolutizeLocalPathArgs(args: string[], cwd: string, pathFlags?: readonly string[]): string[];
 /**
  * A managed-database refusal, raised so the caller decides what it costs.
  *
@@ -157,6 +171,8 @@ export declare function runDriverDbCommand(rawArgs: string[], options?: {
     quiet?: boolean;
 }): Promise<void>;
 export declare function dbCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/** Every subcommand the family dispatches — the help table's keys. */
+export declare const DB_SUBCOMMANDS: string[];
 /**
  * The examples, which are not the same on the managed development database.
  *

package/dist/commands/dev.d.ts

@@ -1,3 +1,4 @@
+import { type AppAddress, type RebaseProjectManifest } from "@rebasepro/types";
 import { type PreparedDatabase } from "../dev-db/prepare.js";
 /**
  * The line the watcher prints when it is about to run the entry again.
@@ -65,15 +66,40 @@ export declare function portMovedNotice(line: string): {
  *
  * @param projectRoot   Absolute path the relative entries are resolved against.
  * @param paths         The `REBASE_DEV_*` map from {@link devRuntimeEnv}.
- * @param includeConfig Whether `config/` is watched here. It is only when
- *                      auto-generation is off; with `--generate` a dedicated
- *                      watcher already regenerates the schema and SDK, and tsx
- *                      restarts on the files that produces.
  */
 export declare function devWatchIncludes(projectRoot: string, paths: {
     REBASE_DEV_FUNCTIONS?: string;
     REBASE_DEV_CRONS?: string;
-}, includeConfig: boolean): string[];
+}): string[];
+/**
+ * The file dev writes to restart the backend, or `null` when tsx would not see it.
+ *
+ * Outside the project, so nothing appears in the developer's tree, and keyed by
+ * the project so two `rebase dev`s never restart each other. tsx ignores every
+ * path with a dot-named segment (its built-in `**\/.*\/**`), so a trigger under
+ * `.rebase/` — or under a TMPDIR inside a dot directory — would never fire; in
+ * that case there is no trigger and {@link devWatchArgs} leaves the
+ * collections to tsx, as before.
+ */
+export declare function devRestartTrigger(projectRoot: string): string | null;
+/**
+ * The `tsx watch` argument list for the backend (unquoted).
+ *
+ * One save of a collection file must restart the backend once. The runtime
+ * `import()`s the collections, so tsx tracks them as dependencies and used to
+ * restart the moment a file was saved — before dev had regenerated
+ * `schema.generated.ts`. That boot warned "schema.generated.ts no longer
+ * describes the database … Run `rebase schema generate`", telling the reader to
+ * run what dev was running at that moment, and the regeneration then rewrote
+ * the file and restarted the backend a second time. So tsx is told to leave the
+ * collections directory alone (`--exclude` wins over its dependency tracking),
+ * and dev restarts the backend itself, once, after the regeneration — through
+ * `restartTrigger`, which tsx watches.
+ */
+export declare function devWatchArgs(projectRoot: string, paths: {
+    REBASE_DEV_FUNCTIONS?: string;
+    REBASE_DEV_CRONS?: string;
+}, entryTarget: string, restartTrigger: string | null): string[];
 /** Well-known filename the backend writes its actual port to. */
 export declare const DEV_PORT_FILENAME = ".rebase-dev-port";
 /**
@@ -138,6 +164,53 @@ export declare function resolveStartPort(projectRoot: string, explicitPort?: num
  * Exported for its test.
  */
 export declare function databaseEndpoint(url: string | null | undefined): string | null;
+/**
+ * What the start banner needs to know about a project's static apps.
+ *
+ * `rebase dev` runs one frontend: Vite in `frontend/`, at the root of its own
+ * localhost port, whatever path or hostname the manifest declares for it. So an
+ * app's local address and its deployed one are different things, and for an app
+ * with a hostname of its own they share nothing at all — appending its address
+ * to the local URL would print `http://localhost:5173https://admin.example.com`.
+ */
+export interface DevStaticShape {
+    declaresStaticApp: boolean;
+    /** The declared app whose `root` is the `frontend/` that `rebase dev` runs, if one is. */
+    served?: {
+        appName: string;
+        address: AppAddress;
+    };
+    /** Where the CMS is, when an app declares one. */
+    cms?: {
+        appName: string;
+        /** Always a path. */
+        path: string;
+        /** The serving app's hostname, when its `path` names one. */
+        host?: string;
+        /** Whether the app serving it is the one `rebase dev` runs, so it has a local address. */
+        servedLocally: boolean;
+    };
+}
+/**
+ * Read {@link DevStaticShape} out of a loaded manifest. Exported for its test.
+ *
+ * Which declared app is running is decided by its `root` being `frontend/`,
+ * because that directory is what `startFrontend` launches and nothing else is.
+ * When no declared app has that root, which app serves the CMS cannot be told,
+ * and it is read as the frontend that does run — what the banner has always
+ * assumed, and right for every project `rebase init` scaffolds.
+ */
+export declare function devStaticShape(manifest: RebaseProjectManifest, projectRoot: string, frontendDir: string | null): DevStaticShape;
+/**
+ * The banner's lines for a project with a frontend. Exported for its test.
+ *
+ * Every address is printed whole, once: the local one Vite answers on, and —
+ * for an app with a hostname — the https URL it answers on once deployed, on a
+ * line of its own beneath it. A CMS in an app `rebase dev` does not run gets its
+ * deployed address and a note saying so, rather than a localhost URL that the
+ * running frontend's SPA fallback would answer with the wrong app.
+ */
+export declare function appBannerLines(frontendUrl: string, api: string, shape: DevStaticShape): Array<[string, string]>;
 /**
  * The `↳ Database =` line: which database, why it was chosen, and where it is.
  *
@@ -206,7 +279,6 @@ export declare const DEV_FLAGS: {
     readonly "--backend-only": BooleanConstructor;
     readonly "--frontend-only": BooleanConstructor;
     readonly "--port": NumberConstructor;
-    readonly "--generate": BooleanConstructor;
     /**
      * Point this run at a database of your own, ahead of everything else.
      *
@@ -220,7 +292,6 @@ export declare const DEV_FLAGS: {
     readonly "-b": "--backend-only";
     readonly "-f": "--frontend-only";
     readonly "-P": "--port";
-    readonly "-g": "--generate";
     readonly "--no-db": BooleanConstructor;
 };
 /**

package/dist/commands/doctor.d.ts

@@ -57,4 +57,9 @@ export declare const DOCTOR_FLAGS: {
     readonly "--sdk": StringConstructor;
     readonly "-k": "--sdk";
 };
+/**
+ * The line handed to the driver, every path on it resolved from where the
+ * command was run — the driver runs in `backend/`. See `utils/path-flags.ts`.
+ */
+export declare function doctorDriverArgs(rawArgs: string[], cwd: string): string[];
 export declare function doctorCommand(rawArgs: string[]): Promise<void>;

package/dist/commands/generate_sdk.d.ts

@@ -1,8 +1,9 @@
 /**
  * CLI command: generate-sdk
  *
- * Reads collection definitions from a specified directory (default: ./config/collections),
- * generates a typed TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
+ * Reads every collection file in a directory (default: ./config/collections) —
+ * the files the backend serves, not the barrel's list — generates a typed
+ * TypeScript SDK, and writes it to the output directory (default: ./generated/sdk).
  *
  * Uses jiti for dynamic TypeScript import of collection files.
  */

package/dist/commands/init.d.ts

@@ -1,4 +1,5 @@
 import type { PackageManager, PMCommands } from "../utils/package-manager.js";
+import { type AgentKey } from "./skills.js";
 /**
  * Every scaffolded file that carries a `{{PLACEHOLDER}}`.
  *
@@ -42,6 +43,10 @@ export interface InitOptions {
     setupKey?: string;
     /** Control-plane URL the setup key is redeemed against. */
     cloudUrl?: string;
+    /** AI coding agents to install skills and the MCP server for. */
+    agents: AgentKey[];
+    /** Whoever reads the closing steps can answer a prompt (a TTY, not --yes). */
+    interactive?: boolean;
 }
 export interface BuildQuestionsParams {
     nameArg?: string;
@@ -105,21 +110,59 @@ 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 "--no-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";
+    "--git": BooleanConstructor;
+    "--install": BooleanConstructor;
+    "--no-install": BooleanConstructor;
+    "--database-url": StringConstructor;
+    "--introspect": BooleanConstructor;
+    "--template": StringConstructor;
+    "--headless": BooleanConstructor;
+    "--project": StringConstructor;
+    "--setup-key": StringConstructor;
+    "--agent": [StringConstructor];
+    "--yes": BooleanConstructor;
+    "-a": string;
+    "-g": string;
+    "-i": string;
+    "-t": string;
+    "-y": string;
 };
+/**
+ * The closing "AI Agent Skills" lines, each command one its reader can run.
+ *
+ * `rebase skills install` with no `--agent` prompts, and refuses without a
+ * TTY — so printing it bare at the end of `rebase init --yes`, the agent and
+ * CI path, told that reader to run a command that answers "Cannot prompt".
+ * Named agents are spelled out (a refresh must not depend on detection, which
+ * never finds Copilot); otherwise a TTY reader gets the prompt, anyone else
+ * the `--agent` form.
+ */
+export declare function agentNextSteps(agents: readonly AgentKey[], interactive: boolean, pm: PMCommands): string[];
+/**
+ * What a directory may already hold for `rebase init` to scaffold into it.
+ *
+ * `git clone` of an empty repository, or `git init`, leaves exactly `.git` —
+ * and `rebase init . --yes --git` is the help's own example. Counting every
+ * entry as "not empty" refused the one directory that example is most likely
+ * to be typed in. The entries here are a repository's metadata, the files
+ * operating systems drop into any folder, and a licence: none of them is
+ * something the scaffold writes (`init.test.ts` holds the template to that),
+ * so tolerating them can never overwrite anything. Everything else is a
+ * conflict and is named, never merged into.
+ */
+export declare const SCAFFOLD_TOLERATED_ENTRIES: ReadonlySet<string>;
+/** Entries in `dir` the scaffold would overwrite or mix with — `[]` when it may proceed. */
+export declare function scaffoldDirectoryConflicts(dir: string): string[];
+/** The refusal for a directory that already holds files, with the two ways forward. */
+export declare function scaffoldConflictMessage(projectName: string, displayPath: string, conflicts: string[]): string[];
+/**
+ * `git init`, or nothing when the directory is already a repository.
+ *
+ * A cloned repository keeps its branch, its remote and its history: the
+ * scaffold is committed on top of what is there. Only a repository this
+ * function created is pointed at `main`.
+ */
+export declare function initGitRepository(targetDirectory: string): Promise<boolean>;
 /**
  * Whether `port` is free — on the wildcard address *and* on both loopback addresses.
  *

package/dist/commands/schema.d.ts

@@ -1 +1,9 @@
+/**
+ * The line handed to the driver, its paths resolved from where the command was
+ * run (the driver runs in `backend/`). `--schema` is left alone: on
+ * `introspect` it names a Postgres schema, not a file.
+ */
+export declare function schemaDriverArgs(rawArgs: string[], cwd: string): string[];
 export declare function schemaCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
+/** Every subcommand the family dispatches — the help table's keys. */
+export declare const SCHEMA_SUBCOMMANDS: string[];

package/dist/commands/skills.d.ts

@@ -18,14 +18,32 @@
  * A subdirectory layout has no such problem: the rule file already sits beside
  * its own assets, so `references/x.md` resolves as written and nothing is
  * loaded until it is opened.
+ *
+ * `homeMarkers` are the directories under `~` that say the assistant is
+ * installed on this machine. They answer a different question from
+ * `detectDir`: a fresh scaffold has no `.claude/` of its own, so `rebase init`
+ * asks the machine which assistants the developer has and pre-selects those.
+ *
+ * `mcp` is where the assistant reads a *project-level* MCP server list, and in
+ * which shape — see `agent-setup.ts`. `projectDir` is what `REBASE_PROJECT_DIR`
+ * is set to: `"."` where the server is spawned in the project, the editor's own
+ * workspace variable where it may not be. `null` means there is no project
+ * file to write: Windsurf reads only a user-level config, and one entry there
+ * cannot name every project on the machine.
  */
-declare const AGENTS: {
+export declare const AGENTS: {
     readonly cursor: {
         readonly label: "Cursor";
         readonly detectDir: ".cursor";
+        readonly homeMarkers: readonly [".cursor"];
         readonly targetDir: ".cursor/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.mdc";
+        readonly mcp: {
+            readonly file: ".cursor/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -35,8 +53,14 @@ declare const AGENTS: {
     readonly claude: {
         readonly label: "Claude Code";
         readonly detectDir: ".claude";
+        readonly homeMarkers: readonly [".claude"];
         readonly targetDir: ".claude/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Claude Code uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -46,9 +70,11 @@ declare const AGENTS: {
     readonly windsurf: {
         readonly label: "Windsurf";
         readonly detectDir: ".windsurf";
+        readonly homeMarkers: readonly [".codeium/windsurf", ".windsurf"];
         readonly targetDir: ".windsurf/rules";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: null;
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -58,8 +84,14 @@ declare const AGENTS: {
     readonly gemini: {
         readonly label: "Gemini CLI / Antigravity";
         readonly detectDir: ".agents";
+        readonly homeMarkers: readonly [".gemini"];
         readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
+        readonly mcp: {
+            readonly file: ".gemini/settings.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** Gemini uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -69,9 +101,15 @@ declare const AGENTS: {
     readonly codex: {
         readonly label: "Codex CLI";
         readonly detectDir: ".codex";
-        readonly targetDir: ".codex/skills";
+        readonly homeMarkers: readonly [".codex"];
+        readonly targetDir: ".agents/skills";
         readonly flatLayout: false;
-        /** Codex reads AGENTS.md; the skills sit beside its own config. */
+        readonly mcp: {
+            readonly file: ".codex/config.toml";
+            readonly format: "codexToml";
+            readonly projectDir: ".";
+        };
+        /** Codex uses the standard SKILL.md format in subdirectories. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
             content: string;
@@ -80,9 +118,15 @@ declare const AGENTS: {
     readonly kiro: {
         readonly label: "Kiro";
         readonly detectDir: ".kiro";
+        readonly homeMarkers: readonly [".kiro"];
         readonly targetDir: ".kiro/steering";
         readonly flatLayout: true;
         readonly indexFile: "rebase.md";
+        readonly mcp: {
+            readonly file: ".kiro/settings/mcp.json";
+            readonly format: "mcpServers";
+            readonly projectDir: ".";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -92,9 +136,15 @@ declare const AGENTS: {
     readonly copilot: {
         readonly label: "GitHub Copilot";
         readonly detectDir: null;
+        readonly homeMarkers: readonly [];
         readonly targetDir: ".github/instructions";
         readonly flatLayout: true;
         readonly indexFile: "rebase.instructions.md";
+        readonly mcp: {
+            readonly file: ".vscode/mcp.json";
+            readonly format: "vscode";
+            readonly projectDir: "${workspaceFolder}";
+        };
         /** The body is not a rule file here — `indexFile` is. */
         readonly transformFile: (skillName: string, content: string) => {
             fileName: string;
@@ -102,7 +152,11 @@ declare const AGENTS: {
         };
     };
 };
-type AgentKey = keyof typeof AGENTS;
+export type AgentKey = keyof typeof AGENTS;
+/** Narrows a string to an agent name, by the table's own keys. */
+export declare function isAgentKey(value: string): value is AgentKey;
+/** Every agent, in table order. */
+export declare const AGENT_KEYS: AgentKey[];
 export interface LoadedSkill {
     name: string;
     /** Absolute path of the skill's source directory. */
@@ -113,6 +167,13 @@ export interface LoadedSkill {
 }
 /** Read all skill directories and return their names, content and assets. */
 export declare function loadSkills(skillsDir: string): LoadedSkill[];
+/**
+ * The skills this CLI ships, from its own `@rebasepro/agent-skills`.
+ *
+ * Throws rather than exiting, so `rebase init` can report a missing bundle as a
+ * warning and still finish the scaffold.
+ */
+export declare function loadBundledSkills(): LoadedSkill[];
 /**
  * The one always-on rule a flat-layout agent gets, in place of every skill.
  *
@@ -136,11 +197,45 @@ export declare function renderSkillIndex(skills: LoadedSkill[], agentKey: AgentK
  * guessing, because the wrong guess installs 21 files and reports success.
  */
 export declare function detectAgents(projectDir: string): AgentKey[];
+/** What `detectInstalledAgents` found for one assistant. */
+export interface InstalledAgent {
+    key: AgentKey;
+    label: string;
+    /** The home directory checked, as `~/…` — the one found, else the first. */
+    marker: string | null;
+    found: boolean;
+}
+/**
+ * Which assistants are installed on this machine, from their home directories.
+ *
+ * The question `rebase init` needs answered, and one `detectAgents` cannot: a
+ * project that does not exist yet has no `.claude/` in it. What the machine has
+ * is only a default — the developer confirms it — so a false positive costs an
+ * unticked box, not 21 files nobody asked for.
+ */
+export declare function detectInstalledAgents(home?: string): InstalledAgent[];
 /** Install skills for a specific agent into the project directory. */
 export declare function installForAgent(agentKey: AgentKey, skills: LoadedSkill[], projectDir: string): {
     skills: number;
     assets: number;
 };
+/** What `installSkills` did for one agent. */
+export interface SkillsInstallResult {
+    agent: AgentKey;
+    skills: number;
+    assets: number;
+    /** An earlier agent in the same run that already wrote this directory. */
+    sharedWith?: AgentKey;
+}
+/**
+ * Install for several agents, writing each target directory once.
+ *
+ * Gemini and Codex both read `.agents/skills`; installing twice would write the
+ * same 21 files twice and report two installs of one directory.
+ */
+export declare function installSkills(agents: readonly AgentKey[], skills: LoadedSkill[], projectDir: string): SkillsInstallResult[];
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const SKILLS_SUBCOMMANDS: readonly ["install"];
 export declare function skillsCommand(subcommand: string | undefined, rawArgs: string[]): Promise<void>;
 /**
  * Agents named explicitly on the command line, e.g. `--agent claude --agent cursor`
@@ -148,4 +243,15 @@ export declare function skillsCommand(subcommand: string | undefined, rawArgs: s
  * given.
  */
 export declare function parseAgentFlags(rawArgs: string[]): AgentKey[] | null;
-export {};
+/** `rebase skills install`'s whole line: the agents it names, and `--mcp`. */
+export declare function parseSkillsInstallLine(rawArgs: string[]): {
+    agents: AgentKey[] | null;
+    mcp: boolean;
+};
+/**
+ * The agents a list of `--agent` values names, or null when it names none.
+ *
+ * Shared by `rebase skills install` and `rebase init`, so both accept the same
+ * spellings. Throws a UsageError on a name that is not an agent.
+ */
+export declare function resolveAgentNames(values: readonly string[]): AgentKey[] | null;

package/dist/commands/start.d.ts

@@ -1 +1,30 @@
+import type { RebaseBundleStatic } from "@rebasepro/types";
+/** The NODE_ENV the runtime will see, and where it comes from. */
+export interface StartNodeEnv {
+    value: string | undefined;
+    source: "shell" | ".env" | "unset";
+}
+/**
+ * What NODE_ENV the server will boot in. The shell wins — dotenv never
+ * overrides a variable that is already set — then `.env`.
+ */
+export declare function startNodeEnv(projectRoot: string): StartNodeEnv;
+/**
+ * The banner for a `rebase start` that is not a production server, or `null`.
+ *
+ * Not forced to production: the scaffold's `.env` points at a loopback
+ * database, which a production boot refuses, so forcing it would break the
+ * documented local run. What must not happen is the silence — a command the
+ * help called "(production)" booting with the first-registration window open.
+ */
+export declare function nonProductionWarning(nodeEnv: StartNodeEnv): string[] | null;
+/**
+ * What to say about the apps a bundle serves only on their own hostname.
+ *
+ * The runtime prints "Server running at http://localhost:<port>", and an app
+ * whose `path` names a hostname answers only requests carrying that `Host` —
+ * so opening the printed URL showed a 404 for an app that was running fine,
+ * and nothing said why. One line per such app, with a command that reaches it.
+ */
+export declare function hostRoutedNotice(staticApps: readonly RebaseBundleStatic[], port: string | undefined): string[];
 export declare function startCommand(rawArgs?: string[]): Promise<void>;

package/dist/commands/telemetry.d.ts

@@ -1 +1,11 @@
+/**
+ * `rebase telemetry` — the command that makes the rest of it inspectable.
+ *
+ * The whole subsystem asks for trust it cannot otherwise earn, and the cheapest
+ * way to earn it is to stop describing the payload and print it. `show` runs
+ * the same builder the sender uses, so what appears here is what would go, not
+ * a documentation comment that quietly fell out of date two releases ago.
+ */
+/** Everything the switch below dispatches, for the did-you-mean. */
+export declare const TELEMETRY_SUBCOMMANDS: readonly ["status", "show", "enable", "disable"];
 export declare function telemetryCommand(rawArgs: string[]): Promise<void>;