@layers/amba 0.1.1

package/dist/auth.d.ts

@@ -0,0 +1,69 @@
+export interface Credentials {
+    access_token: string;
+    refresh_token: string;
+    expires_at: string;
+}
+/**
+ * Personal Access Token prefix — `amb_dpat_` followed by 32 random
+ * characters. The CLI accepts a PAT via the `--token <pat>` flag or the
+ * `AMBA_PAT` env var as a stored-credentials replacement, enabling
+ * headless / CI / agent use without the browser flow.
+ */
+export declare const PAT_PREFIX = "amb_dpat_";
+/**
+ * Start a temporary local HTTP server, open the browser for OAuth,
+ * and wait for the redirect callback carrying the token.
+ */
+export declare function browserAuthFlow(): Promise<Credentials>;
+/**
+ * Store credentials to ~/.amba/credentials.json
+ */
+export declare function storeCredentials(creds: Credentials): Promise<void>;
+/**
+ * Load stored credentials. Throws if not found.
+ */
+export declare function loadCredentials(): Promise<Credentials>;
+/**
+ * Check if the access token is expired (with 60s buffer).
+ */
+export declare function isTokenExpired(creds: Credentials): boolean;
+/**
+ * Remove stored credentials.
+ */
+export declare function clearCredentials(): Promise<void>;
+/**
+ * Set the process-scoped bearer override. Called by the global
+ * `preAction` hook with the resolved value (flag → env → null).
+ * `null` clears any prior override.
+ */
+export declare function setBearerOverride(token: string | null): void;
+/** Test-only: reset the override between cases. */
+export declare function __resetTokenOverride(): void;
+/**
+ * Resolve the bearer token to send on the next admin API call.
+ *
+ * Returns the override (PAT or JWT supplied via flag/env) when set,
+ * otherwise loads + expiry-checks the stored access token. Throws
+ * with an actionable error message in either failure path.
+ */
+export declare function resolveBearerToken(): Promise<string>;
+/**
+ * Compute the bearer-override value the CLI should install for this
+ * invocation. Pure function — exported for testability. Caller wires
+ * the result into `setBearerOverride` (typically inside commander's
+ * `preAction` hook in `index.ts`).
+ *
+ *   resolveTokenSource({ flagToken: '...', envToken: '...' })
+ *     → flag wins
+ *
+ *   resolveTokenSource({ envToken: '...' })
+ *     → env used
+ *
+ *   resolveTokenSource({})
+ *     → null (CLI falls back to stored creds at request time)
+ */
+export interface ResolveTokenSourceInput {
+    flagToken?: string | undefined;
+    envToken?: string | undefined;
+}
+export declare function resolveTokenSource(input: ResolveTokenSourceInput): string | null;

package/dist/bundle.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Customer-function bundling for `amba functions deploy`.
+ *
+ * Uses esbuild (the Workers ecosystem bundler-of-record). The shared
+ * runtime stdlib is marked `external` so customer bundles don't
+ * re-include megabytes of `@anthropic-ai/sdk`, `postgres`, `zod`, etc.;
+ * these resolve at dispatch time via platform-level bindings.
+ *
+ * Two checks gate the bundle before upload:
+ *   1. Pre-upload size check against `BUNDLE_MAX_SIZE_BYTES` (8 MB
+ *      default — the platform's 10 MB compressed cap minus 2 MB
+ *      headroom) with a clear error pointing at the externalization
+ *      config.
+ *   2. Bundle-shape report — the CLI prints what's externalized vs
+ *      bundled at deploy time so size issues are debuggable.
+ */
+import { type BuildOptions } from 'esbuild';
+/**
+ * Modules customer code MUST externalize. The runtime exposes these as
+ * platform-level bindings; bundling them per-script wastes hundreds of
+ * KB to MBs and quickly hits the script-size cap.
+ */
+export declare const RUNTIME_STDLIB_EXTERNALS: readonly string[];
+/**
+ * Default maximum bundle size — 8 MB compressed. CF's hard cap is 10 MB
+ * compressed (paid plan); we reject at 8 MB to leave headroom for the
+ * compression-ratio variance and for the dispatch-namespace metadata.
+ */
+export declare const BUNDLE_MAX_SIZE_BYTES: number;
+export declare class BundleSizeError extends Error {
+    readonly sizeBytes: number;
+    readonly maxBytes: number;
+    constructor(sizeBytes: number, maxBytes: number);
+}
+export interface BundleResult {
+    /** The bundled JS source (UTF-8). */
+    code: string;
+    /** SHA-256 hex of the bundle (used for `function_deployments.bundle_sha`). */
+    sha256: string;
+    /** Compressed size in bytes (gzipped — what CF measures against the cap). */
+    compressedSize: number;
+    /** Uncompressed size in bytes — for human-friendly CLI output. */
+    uncompressedSize: number;
+    /** What esbuild externalized vs bundled in this build (CLI display). */
+    externals: string[];
+}
+export interface BundleOptions {
+    /** Path to the customer's entry file, e.g. `./functions/scan-letter.ts`. */
+    entryPoint: string;
+    /** Override the max bundle size. */
+    maxSizeBytes?: number;
+    /** Additional externals beyond `RUNTIME_STDLIB_EXTERNALS`. */
+    extraExternals?: string[];
+    /** Source map handling. Default: inline. */
+    sourcemap?: BuildOptions['sourcemap'];
+}
+/**
+ * Bundle a customer function file for upload to a Workers dispatch
+ * namespace. Returns the bundled code + metadata; throws
+ * `BundleSizeError` when the compressed size exceeds the cap so the CLI
+ * can surface a clear error.
+ */
+export declare function bundleFunction(options: BundleOptions): Promise<BundleResult>;
+/**
+ * Print the bundle's externalization report to stdout. Intended to be
+ * called from `amba functions deploy` after bundling so customers can
+ * see what got externalized vs included at a glance.
+ */
+export declare function printBundleReport(bundle: BundleResult): void;

package/dist/commands/ai.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `amba ai providers ...` — register / list / remove AI provider API keys.
+ *
+ * Wire path: CLI → platform admin API. Plaintext is stored canonically
+ * server-side; the CLI never echoes plaintext back. The API returns a
+ * `api_key_preview` (first-6 + last-4) for confirmation.
+ */
+export interface AiProvidersAddOptions {
+    /** API key plaintext. Mutually exclusive with `--from-stdin`. */
+    key?: string;
+    /**
+     * When set, read the key from stdin instead of `--key`. Same shape as
+     * `amba secrets set --from-stdin` for keep-out-of-shell-history flows.
+     */
+    fromStdin?: boolean;
+}
+export declare function aiProvidersAddCommand(provider: string, options: AiProvidersAddOptions): Promise<void>;
+export declare function aiProvidersListCommand(): Promise<void>;
+export declare function aiProvidersDeleteCommand(provider: string): Promise<void>;
+/**
+ * Read a secret value from CLI options. Shared by `amba ai providers
+ * add` and `amba secrets set` — either `--key`/`<value>` arg OR
+ * `--from-stdin` for shell-history-safe input.
+ *
+ * Resolution order:
+ *   1. `--from-stdin` → consume stdin to EOF, return trimmed value.
+ *      Errors if stdin is a TTY (would hang waiting for input the
+ *      caller can't see they need to type).
+ *   2. `--key` (or its inline equivalent) → return as-is.
+ *   3. Neither → throw with the actionable error message.
+ */
+export declare function resolveSecretValue(opts: {
+    key?: string;
+    fromStdin?: boolean;
+}): Promise<string>;

package/dist/commands/analytics.d.ts

@@ -0,0 +1,14 @@
+export type AnalyticsType = 'users' | 'events';
+export type AnalyticsFormat = 'csv' | 'ndjson';
+export interface AnalyticsExportOptions {
+    type: AnalyticsType;
+    project?: string;
+    since?: string;
+    until?: string;
+    out?: string;
+    limit?: number;
+    format?: AnalyticsFormat;
+    /** Test seam: cap the number of pages walked when paginating events. */
+    maxPages?: number;
+}
+export declare function analyticsExportCommand(opts: AnalyticsExportOptions): Promise<void>;

package/dist/commands/collections.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `amba collections ...` — thin shells over the admin collection routes.
+ *
+ * Wire shapes:
+ *
+ *   POST   /admin/projects/:p/collections             — create (full schema)
+ *   GET    /admin/projects/:p/collections             — list
+ *   PATCH  /admin/projects/:p/collections/:name       — single-op alter
+ *   DELETE /admin/projects/:p/collections/:name       — drop (requires ?confirm)
+ *
+ * The CLI's job is to:
+ *   1. Validate names / types client-side so an obviously-bad invocation
+ *      doesn't round-trip.
+ *   2. Translate the user-friendly CLI flag shape (`--field name:type`,
+ *      `--add-field`, `--drop-field`) into the wire shape (single op per
+ *      PATCH).
+ *   3. Block until the server reports success.
+ *   4. Surface server errors with a sensible CLI message.
+ *
+ * Multi-op alters are issued sequentially so the operator audit trail
+ * stays one-to-one with developer actions.
+ */
+export interface CollectionsCreateOptions {
+    /** Field specs in `name:type[:nullable]` form. May repeat. */
+    field: string[];
+    /** Index specs — one or more comma-separated `<col> [asc|desc]` entries. */
+    index: string[];
+}
+export declare function collectionsCreateCommand(name: string, options: CollectionsCreateOptions): Promise<void>;
+export interface CollectionsAlterOptions {
+    /** Add columns (`name:type[:nullable]`). */
+    addField: string[];
+    /** Drop columns (by name). DROP COLUMN is destructive — confirm with --confirm. */
+    dropField: string[];
+    /** Add indexes (same spec syntax as create). */
+    addIndex: string[];
+    /**
+     * Per data's API: drop_column requires `?confirm=<column-name>`. The
+     * CLI surfaces this as a flag listing the columns the developer is
+     * confirming; we cross-check against `dropField` below.
+     */
+    confirm?: string[];
+}
+export declare function collectionsAlterCommand(name: string, options: CollectionsAlterOptions): Promise<void>;
+export declare function collectionsListCommand(): Promise<void>;
+export declare function collectionsDropCommand(name: string, options?: {
+    confirm?: string;
+}): Promise<void>;

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+export declare function configListCommand(): Promise<void>;
+export declare function configSetCommand(key: string, rawValue: string): Promise<void>;

package/dist/commands/db.d.ts

@@ -0,0 +1,4 @@
+export interface DbMigrateOptions {
+    project?: string;
+}
+export declare function dbMigrateCommand(opts?: DbMigrateOptions): Promise<void>;

package/dist/commands/functions-logs.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `amba functions logs <name>` — read recent log events.
+ *
+ * Two modes:
+ *   - One-shot (default): fetch events in `[since, until)` and exit.
+ *   - `--tail`: print the last hour's events, then poll every 3s for
+ *     new events past the highest seen `EventTimestampMs`. Ctrl+C to stop.
+ *
+ * Output formatting:
+ *   - `--json`: NDJSON to stdout (one event per line) so `| jq` works.
+ *   - default: human-readable lines:
+ *       2026-05-08T12:34:56.789Z scan-letter-v3 [info] "scanning"
+ *       2026-05-08T12:34:57.012Z scan-letter-v3 [exception] TypeError: …
+ *
+ * Server-side scoping is enforced — the API filters by ScriptName
+ * prefix so a developer can never read another tenant's logs.
+ */
+export interface FunctionsLogsOptions {
+    /** ISO 8601 inclusive start. Defaults to 1 hour ago (or last-seen on tail). */
+    since?: string;
+    /** ISO 8601 exclusive end. Defaults to now. Ignored on tail. */
+    until?: string;
+    /** Max events per fetch. Default 100, max 1000. */
+    limit?: number;
+    /** Tail mode — poll every 3s. */
+    tail?: boolean;
+    /** NDJSON output. */
+    json?: boolean;
+}
+export declare function functionsLogsCommand(functionName: string, options?: FunctionsLogsOptions): Promise<void>;

package/dist/commands/functions.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `amba functions ...` commands.
+ *
+ * `deploy` bundles the entry file with esbuild (externalizing the runtime
+ * stdlib + size-checking before upload), then POSTs the bundle to the
+ * platform API. The server resolves bindings, uploads the script, and
+ * records the deployment in a single round-trip. The other subcommands
+ * are thin shells over the admin API helpers in `api-client.ts`.
+ */
+import { type RateLimitConfig } from '../_internal/shared.js';
+export interface DeployOptions {
+    /** Override the function name. Default: filename without extension. */
+    name?: string;
+    /** Print bundle report but skip the CF API + DB write. Useful for size triage. */
+    dryRun?: boolean;
+    /**
+     * Optional declarative rate-limit config. All three sub-fields must be
+     * provided together; any one missing is a deploy error. Validated via
+     * `validateRateLimitConfig` before the API roundtrip so typos fail
+     * fast on the developer's machine. Persisted on the deployment row;
+     * the edge router enforces it pre-dispatch.
+     */
+    rateLimitWindow?: string;
+    rateLimitMax?: number;
+    rateLimitKey?: string;
+}
+export declare function functionsDeployCommand(entryPoint: string, options?: DeployOptions): Promise<void>;
+export declare function functionsListCommand(): Promise<void>;
+export declare function functionsDeleteCommand(name: string, options?: {
+    confirm?: string;
+}): Promise<void>;
+export declare function functionsScheduleCommand(name: string, cron: string, options?: {
+    tz?: string;
+}): Promise<void>;
+/**
+ * `amba functions dev` — not configured in this release. Use
+ * `amba functions deploy <file>` to deploy via the platform API.
+ */
+export declare function functionsDevCommand(_entryPoint: string): Promise<void>;
+/**
+ * `amba functions consume <queue> <function>` — bind a function as the
+ * consumer for a queue. Customers send to a queue with `ctx.queue.send`;
+ * the genericQueueJobWorkflow looks up the binding and invokes the
+ * bound function with the payload.
+ *
+ * Single binding per (project, queue). Re-running with a different
+ * function-name overwrites — same upsert semantics as `amba secrets set`.
+ */
+export declare function functionsConsumeCommand(queueName: string, functionName: string, options?: {
+    paused?: boolean;
+}): Promise<void>;
+/**
+ * `amba functions consumers list` / `amba functions consumers unbind`
+ * sub-tree. Mirrors the `amba secrets list` shape so the CLI surface
+ * stays consistent.
+ */
+export declare function functionsConsumersListCommand(): Promise<void>;
+export declare function functionsConsumersUnbindCommand(queueName: string): Promise<void>;
+/**
+ * Resolve the optional rate-limit config from CLI flags. Returns the
+ * validated config if all three sub-flags are set, `null` if all three
+ * are absent, or throws if a partial set was supplied.
+ *
+ * The "all-or-nothing" rule is intentional — defaulting any sub-flag
+ * is too easy to mis-set. A customer who types `--rate-limit-max 20`
+ * expecting "use a default 60s window with ip key" would silently get
+ * NO rate limit instead, which is the wrong default for a security-
+ * adjacent flag. Forcing all three to be explicit means the failure
+ * mode is "fail loud at deploy" not "silently no rate limit."
+ */
+declare function parseRateLimitFlags(options: DeployOptions): RateLimitConfig | null;
+/**
+ * Test-only re-export of internal helpers. Not a public API — anything
+ * here is unstable across patches.
+ */
+export declare const __testHelpers: {
+    parseRateLimitFlags: typeof parseRateLimitFlags;
+};
+export {};

package/dist/commands/init.d.ts

@@ -0,0 +1,12 @@
+export interface InitOptions {
+    withExample?: boolean;
+    /**
+     * The first `amba init` per developer mints a **personal dev** project
+     * (free tier, separate billing class). Default environment for `init`
+     * is therefore `'development'`. Pass `--env=production` to opt into a
+     * production project at init time (rare — most production projects are
+     * minted via `amba projects create --env production` by automation).
+     */
+    env?: 'development' | 'production';
+}
+export declare function initCommand(options?: InitOptions): Promise<void>;

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(): Promise<void>;

package/dist/commands/logs.d.ts

@@ -0,0 +1,16 @@
+export interface LogsTailOptions {
+    project?: string;
+    follow?: boolean;
+    json?: boolean;
+    since?: string;
+    eventName?: string;
+    userId?: string;
+    limit?: number;
+    /** Polling interval in ms when --follow is set. Tests inject a small value. */
+    pollIntervalMs?: number;
+    /** Test seam: stop polling after N iterations. Production callers omit. */
+    maxFollowIterations?: number;
+    /** Test seam: AbortSignal to terminate the follow loop cleanly. */
+    signal?: AbortSignal;
+}
+export declare function logsTailCommand(opts?: LogsTailOptions): Promise<void>;

package/dist/commands/projects.d.ts

@@ -0,0 +1,11 @@
+export declare function projectsListCommand(): Promise<void>;
+export declare function projectsCreateCommand(input: {
+    name: string;
+    env?: string;
+    bundleId?: string;
+    platform?: string;
+}): Promise<void>;
+export declare function projectsShowCommand(projectId: string): Promise<void>;
+export declare function projectsDeleteCommand(projectId: string, opts?: {
+    yes?: boolean;
+}): Promise<void>;

package/dist/commands/push.d.ts

@@ -0,0 +1 @@
+export declare function pushTestCommand(): Promise<void>;

package/dist/commands/schema.d.ts

@@ -0,0 +1,7 @@
+export type SchemaFormat = 'json' | 'typescript';
+export type SchemaDomain = 'all' | 'achievements' | 'streaks' | 'xp' | 'leaderboards' | 'challenges' | 'content' | 'segments' | 'push';
+export interface SchemaExportOptions {
+    domain: SchemaDomain;
+    format?: SchemaFormat;
+}
+export declare function schemaExportCommand(opts: SchemaExportOptions): Promise<void>;

package/dist/commands/secrets.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `amba secrets ...` — write per-function secrets through the platform
+ * API. The CLI sends `{name, value, function}` to the admin endpoint;
+ * the server stores the value, validates reserved binding names, and
+ * propagates it to the deployed Worker's binding. Sync is eventual —
+ * `amba secrets list` shows progress.
+ */
+export interface SecretsSetOptions {
+    /** Function name the secret binds to. Required — there are no project-wide secrets. */
+    function: string;
+    /**
+     * Environment selector. Currently informational: both `dev` and `prod`
+     * write to the same secret namespace per project. Workarounds:
+     *   - Per-env naming convention: `STRIPE_KEY_DEV` vs `STRIPE_KEY_PROD`.
+     *   - Two separate amba projects, one per env.
+     */
+    env?: 'dev' | 'prod';
+    /**
+     * Read the secret value from stdin instead of the positional `value`
+     * arg. Keeps the secret out of shell history. Mutually exclusive with
+     * a non-empty `value`.
+     */
+    fromStdin?: boolean;
+}
+export declare function secretsSetCommand(name: string, value: string | undefined, options: SecretsSetOptions): Promise<void>;
+export declare function secretsListCommand(): Promise<void>;
+export declare function secretsUnsetCommand(name: string, options: {
+    function: string;
+}): Promise<void>;

package/dist/commands/seed.d.ts

@@ -0,0 +1,6 @@
+export type SeedPreset = 'starter' | 'gamification' | 'content';
+export interface SeedOptions {
+    project?: string;
+    preset?: SeedPreset;
+}
+export declare function seedCommand(opts?: SeedOptions): Promise<void>;

package/dist/commands/sites.d.ts

@@ -0,0 +1,84 @@
+/**
+ * `amba sites ...` commands.
+ *
+ * Static-site hosting. The CLI orchestrates two halves on every deploy:
+ *
+ *   1. Register the site row in the control plane via the admin API so
+ *      domains can attach with a stable `cert_status` for polling.
+ *   2. Upload the pre-built static directory through the platform API,
+ *      which proxies to the underlying CDN.
+ *
+ * This command does NOT build static files — accept a pre-built
+ * directory (mirrors `wrangler pages deploy ./out` semantics). Dynamic
+ * logic belongs in `amba functions deploy`, not in a site directory.
+ */
+export interface SitesDeployOptions {
+    /** Site name. Defaults to the leaf directory name. */
+    name?: string;
+    /** Skip CF upload; just print what would happen. */
+    dryRun?: boolean;
+}
+export declare function sitesDeployCommand(inputDir: string, options?: SitesDeployOptions): Promise<void>;
+export declare function sitesListCommand(): Promise<void>;
+/**
+ * `amba sites logs <name>` — not yet available via the public API. Use
+ * the developer console for deployment history, or `amba sites describe`
+ * for the current cert / domain state.
+ */
+export declare function sitesLogsCommand(name: string): Promise<void>;
+export declare function sitesRollbackCommand(name: string, options?: {
+    to?: string;
+}): Promise<void>;
+export interface SitesDomainAddOptions {
+    /** Required — which site this domain points at. */
+    site: string;
+    /** Reserved for backwards compatibility; ignored. */
+    zoneId?: string;
+    /** Skip the cert poll loop. Caller will check status later. */
+    noWait?: boolean;
+    /** Max seconds to wait for cert_status='active' before bailing. Default 600. */
+    timeout?: number;
+}
+export declare function sitesDomainAddCommand(hostname: string, options: SitesDomainAddOptions): Promise<void>;
+export declare function sitesDomainListCommand(siteName: string): Promise<void>;
+export declare function sitesDomainRemoveCommand(hostname: string, options: {
+    site: string;
+    zoneId?: string;
+}): Promise<void>;
+export declare function sitesDisableCommand(name: string): Promise<void>;
+export declare function sitesEnableCommand(name: string): Promise<void>;
+export declare function sitesArchiveCommand(name: string, options?: {
+    confirm?: string;
+}): Promise<void>;
+interface SiteFile {
+    /** Path relative to the input dir, with forward slashes. */
+    relPath: string;
+    absPath: string;
+    size: number;
+}
+/**
+ * Recursively walk `dir` and return every file, skipping common build
+ * detritus (`.DS_Store`, `.git`). Dynamic-handler inputs (`_worker.*`,
+ * `functions/`, `_routes.json`, `_middleware.*`) are rejected.
+ */
+declare function collectFiles(dir: string): Promise<SiteFile[]>;
+/**
+ * Distinct error class so tests can assert on the specific Decision
+ * Log #10 rejection rather than string-matching the message. CLI's
+ * `runAction` wrapper renders Errors uniformly so users still see the
+ * full message.
+ */
+export declare class SitesStaticOnlyError extends Error {
+    readonly code: "SITES_STATIC_ONLY";
+}
+/**
+ * Test-only re-export of internal helpers. Tests reach in via this
+ * namespace so the production module surface stays clean. Not a public
+ * API — anything here is unstable across patches.
+ */
+export declare const __testHelpers: {
+    collectFiles: typeof collectFiles;
+    BLOCKED_FILE_NAMES: Set<string>;
+    BLOCKED_DIR_NAMES: Set<string>;
+};
+export {};

package/dist/commands/status.d.ts

@@ -0,0 +1,4 @@
+export interface StatusOptions {
+    detailed?: boolean;
+}
+export declare function statusCommand(opts?: StatusOptions): Promise<void>;

package/dist/commands/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `amba types generate [--watch]` — emits `.amba/types.d.ts`.
+ *
+ * One-shot is the default (CI-friendly). `--watch` is opt-in; the
+ * engine emits deterministic output (no embedded timestamps unless we
+ * pass `bannerTimestamp`), so the CLI compares strings to decide
+ * whether to touch the file.
+ */
+export interface TypesGenerateOptions {
+    /** Output path. Default: `.amba/types.d.ts` under the current working directory. */
+    out?: string;
+    watch?: boolean;
+}
+export declare function typesGenerateCommand(options?: TypesGenerateOptions): Promise<void>;

package/dist/context-files.d.ts

@@ -0,0 +1,12 @@
+interface ContextFileOptions {
+    projectId: string;
+    projectName: string;
+    apiKey: string;
+    framework: 'expo' | 'react-native' | 'web' | 'unknown';
+    cwd: string;
+}
+/**
+ * Write both context files to the project directory.
+ */
+export declare function generateContextFiles(opts: ContextFileOptions): Promise<string[]>;
+export {};

package/dist/env.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Read `AMBA_PROJECT_ID` from `.env.local` / `.env` in the given directory.
+ * Returns null if not found.
+ */
+export declare function getProjectIdFromEnv(cwd: string): Promise<string | null>;
+/**
+ * Resolve a project id in priority order:
+ *   1. Explicit arg (e.g. `--project <id>`)
+ *   2. `.env.local` / `.env` in cwd
+ *
+ * Prints a helpful error message and exits 1 if no id is found.
+ */
+export declare function requireProjectId(cwd: string, explicit?: string | null): Promise<string>;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};