@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/commands/db/utils/sql-table-extractor.d.ts

@@ -16,11 +16,82 @@
  * Architecture:
  * - Primary: libpg-query AST parsing (accurate, handles edge cases)
  * - Fallback: Regex parsing (for pj-repos without libpg-query)
+ * - Split modules: regex, rls, ast (see sql-table-extractor-*.ts)
  *
  * Note: This is a lightweight parser for manifest generation.
  * For full SQL parsing, use pg_catalog queries (see introspectColumns).
  */
-import type { TableEntry } from '@runa-ai/runa/manifests';
+import type { ForeignKeyDefinition, TableEntry } from '@runa-ai/runa/manifests';
+type SqlParserUtils = Awaited<ReturnType<typeof import('@runa-ai/runa/ast').loadSqlParserUtils>>;
+/**
+ * Get SQL parser utilities (requires AST to be available)
+ */
+export declare function getSqlParserUtils(): Promise<SqlParserUtils | null>;
+/**
+ * Regex patterns for SQL parsing (used as fallback when libpg-query unavailable)
+ */
+export declare const SQL_IDENTIFIER = "(?:\"(?:[^\"]|\"\")*\"|[a-zA-Z_][a-zA-Z0-9_]*)";
+export declare const TABLE_REFERENCE = "(?:\"(?:[^\"]|\"\")*\"|[a-zA-Z_][a-zA-Z0-9_]*)(?:\\s*\\.\\s*(?:\"(?:[^\"]|\"\")*\"|[a-zA-Z_][a-zA-Z0-9_]*))?";
+export declare const SQL_PATTERNS: {
+    readonly createTable: RegExp;
+    readonly primaryKey: RegExp;
+    readonly foreignKey: RegExp;
+    readonly createIndex: RegExp;
+    readonly enableRls: RegExp;
+};
+export interface ParsedTable {
+    schema: string;
+    name: string;
+    lineNumber: number;
+    tableBody: string;
+}
+export interface ParseContext {
+    filePath: string;
+    content: string;
+    lines: string[];
+}
+export declare function splitTopLevelSqlStatements(content: string): string[];
+export declare function splitTopLevelCsv(content: string): string[];
+/**
+ * Convert snake_case to camelCase
+ */
+export declare function snakeToCamel(str: string): string;
+/**
+ * Get line number from character position
+ */
+export declare function getLineNumber(content: string, position: number): number;
+/**
+ * Extract table body (content between parentheses)
+ */
+export declare function extractTableBody(content: string, startPos: number): string;
+/**
+ * Normalize PostgreSQL data type
+ */
+export declare function normalizeType(type: string): string;
+/**
+ * Unquote PostgreSQL identifier and unescape doubled quotes.
+ */
+export declare function unquoteIdentifier(identifier: string): string;
+export declare function parseTableReference(ref: string): {
+    schema: string;
+    name: string;
+} | null;
+/**
+ * Strip SQL comments while preserving quoted text and line structure.
+ */
+/**
+ * Parse index column names from raw SQL fragment
+ *
+ * Handles:
+ * - Quoted identifiers: "timestamp" → timestamp
+ * - Sort directions: created_at DESC → created_at
+ * - Mixed: "user_id" ASC, "created_at" DESC → [user_id, created_at]
+ */
+export declare function parseIndexColumns(rawColumns: string): string[];
+/**
+ * Normalize ON DELETE/UPDATE action
+ */
+export declare function normalizeOnAction(action: string | undefined): ForeignKeyDefinition['onDelete'];
 export interface ExtractOptions {
     /** Include column definitions */
     includeColumns?: boolean;
@@ -31,6 +102,12 @@ export interface ExtractOptions {
     /** Include RLS policies */
     includeRlsPolicies?: boolean;
 }
+export interface ResolvedOptions {
+    includeColumns: boolean;
+    includeForeignKeys: boolean;
+    includeIndexes: boolean;
+    includeRlsPolicies: boolean;
+}
 /**
  * Extract table definitions from SQL files
  *
@@ -53,4 +130,5 @@ export declare function extractTablesFromSqlDir(sqlDir: string, options?: Extrac
  * Uses libpg-query AST parsing when available, falls back to regex parsing.
  */
 export declare function extractTablesFromSqlFile(filePath: string, options?: ExtractOptions): Promise<TableEntry[]>;
+export {};
 //# sourceMappingURL=sql-table-extractor.d.ts.map

package/dist/commands/db/utils/table-registry-introspection.d.ts

@@ -0,0 +1,68 @@
+/**
+ * AI HINT: Table Registry - DB Introspection Module
+ *
+ * Purpose: Database introspection logic for table registry manifest generation
+ * Pattern: DB Introspection PRIMARY, SQL regex FALLBACK
+ *
+ * Extracted from table-registry.ts to reduce file size.
+ * Contains:
+ * - SQL injection prevention helpers (validatePgIdentifier, buildSafeSchemaInClause)
+ * - introspectTablesFromDb (PRIMARY source via PostgreSQL system catalogs)
+ * - Lookup map builders (FK, index, RLS, check constraints, triggers, PK)
+ * - convertIntrospectionToTableEntries
+ * - crossCheckWithDrizzle (Drizzle validation)
+ * - introspectColumns (enriched column info from DB)
+ *
+ * @see table-registry.ts - Main manifest generation and load/save
+ */
+import type { TableEntry } from '@runa-ai/runa/manifests';
+/**
+ * SECURITY (Issue #535): Build safe SQL IN clause for schema names.
+ *
+ * Each schema name is:
+ * 1. Validated to be a safe PostgreSQL identifier
+ * 2. Escaped as a string literal (defense-in-depth)
+ *
+ * @param schemas - Array of schema names to include
+ * @returns SQL fragment like "'public','accounts'" (without parentheses)
+ * @throws Error if any schema name is invalid
+ */
+export declare function buildSafeSchemaInClause(schemas: string[]): string;
+/**
+ * Introspect tables from database using PostgreSQL system catalogs
+ *
+ * This is the PRIMARY source for table metadata (when database is available).
+ * PostgreSQL system catalogs are 100% accurate because PostgreSQL itself
+ * parsed and stored the schema information.
+ *
+ * @param databaseUrl - PostgreSQL connection string
+ * @param schemas - Schema names to include (default: auto-detect non-system schemas)
+ * @returns TableEntry[] with accurate metadata from database
+ * @throws Error if database connection or introspection fails
+ */
+export declare function introspectTablesFromDb(databaseUrl: string, schemas?: string[]): Promise<TableEntry[]>;
+/**
+ * Cross-check SQL tables with Drizzle schema
+ *
+ * Uses dynamic import to load Drizzle schema and verify table names match.
+ * Returns discrepancies if any.
+ *
+ * Note: This is for validation only. SQL is the SSOT.
+ */
+export declare function crossCheckWithDrizzle(sqlTables: TableEntry[], drizzleSchemaPath: string): Promise<{
+    matched: TableEntry[];
+    sqlOnly: TableEntry[];
+    drizzleOnly: string[];
+}>;
+/**
+ * Introspect column information from database
+ *
+ * Zero Hardcode: All info from pg_catalog
+ * This enriches SQL-extracted data with runtime database metadata.
+ *
+ * @param databaseUrl - PostgreSQL connection string
+ * @param tables - Tables to introspect
+ * @returns Tables with enriched column information
+ */
+export declare function introspectColumns(databaseUrl: string, tables: TableEntry[]): Promise<TableEntry[]>;
+//# sourceMappingURL=table-registry-introspection.d.ts.map

package/dist/commands/db/utils/table-registry.d.ts

@@ -20,46 +20,10 @@
  * @see packages/sdk/src/core/manifests/types.ts - TablesManifest type definition
  * @see packages/sdk/src/test/generator/introspectors/db-introspector.ts - DB introspection
  * @see packages/cli/src/commands/db/utils/sql-table-extractor.ts - SQL parser (fallback)
+ * @see table-registry-introspection.ts - DB introspection logic (extracted)
  */
-import type { TableEntry, TablesManifest } from '@runa-ai/runa/manifests';
+import type { TablesManifest } from '@runa-ai/runa/manifests';
 import { type MappingOptions } from './semantic-mapper.js';
-/**
- * Introspect tables from database using PostgreSQL system catalogs
- *
- * This is the PRIMARY source for table metadata (when database is available).
- * PostgreSQL system catalogs are 100% accurate because PostgreSQL itself
- * parsed and stored the schema information.
- *
- * @param databaseUrl - PostgreSQL connection string
- * @param schemas - Schema names to include (default: auto-detect non-system schemas)
- * @returns TableEntry[] with accurate metadata from database
- * @throws Error if database connection or introspection fails
- */
-export declare function introspectTablesFromDb(databaseUrl: string, schemas?: string[]): Promise<TableEntry[]>;
-/**
- * Cross-check SQL tables with Drizzle schema
- *
- * Uses dynamic import to load Drizzle schema and verify table names match.
- * Returns discrepancies if any.
- *
- * Note: This is for validation only. SQL is the SSOT.
- */
-export declare function crossCheckWithDrizzle(sqlTables: TableEntry[], drizzleSchemaPath: string): Promise<{
-    matched: TableEntry[];
-    sqlOnly: TableEntry[];
-    drizzleOnly: string[];
-}>;
-/**
- * Introspect column information from database
- *
- * Zero Hardcode: All info from pg_catalog
- * This enriches SQL-extracted data with runtime database metadata.
- *
- * @param databaseUrl - PostgreSQL connection string
- * @param tables - Tables to introspect
- * @returns Tables with enriched column information
- */
-export declare function introspectColumns(databaseUrl: string, tables: TableEntry[]): Promise<TableEntry[]>;
 export interface GenerateManifestOptions {
     /** SQL directory (default: supabase/schemas/declarative) */
     sqlDir?: string;
@@ -113,4 +77,5 @@ export declare function loadTablesManifest(projectRoot: string): TablesManifest
 export type { TableEntry, TablesManifest } from '@runa-ai/runa/manifests';
 export { applyMappingToTables, generateMapping, generateSemanticName, type MappingOptions, type MappingResult, snakeToCamel, snakeToPascal, validateCompleteness, validateMapping, } from './semantic-mapper.js';
 export { extractTablesFromSqlDir, extractTablesFromSqlFile } from './sql-table-extractor.js';
+export { crossCheckWithDrizzle, introspectColumns, introspectTablesFromDb, } from './table-registry-introspection.js';
 //# sourceMappingURL=table-registry.d.ts.map

package/dist/commands/dev/actors/app-lifecycle.d.ts

@@ -0,0 +1,18 @@
+export interface AppStartInput {
+    repoRoot: string;
+    appDir: string;
+    port: number;
+    tmpDir: string;
+    stream: boolean;
+    bundler?: 'turbopack' | 'webpack';
+}
+export interface AppStartOutput {
+    pid: number;
+    cleanupStreams: () => void;
+}
+export interface ShutdownInput {
+    pid: number;
+}
+export declare const appStartActor: import("xstate").PromiseActorLogic<AppStartOutput, AppStartInput, import("xstate").EventObject>;
+export declare const shutdownActor: import("xstate").PromiseActorLogic<void, ShutdownInput, import("xstate").EventObject>;
+//# sourceMappingURL=app-lifecycle.d.ts.map

package/dist/commands/dev/actors/index.d.ts

@@ -1,14 +1,24 @@
 /**
  * AI HINT: Dev Command Actors
  *
- * Purpose: Re-export actors from build and ci commands
- * Pattern: Actor reuse for dev workflow
+ * Purpose: Re-export all actors for the dev workflow
  *
  * Actors:
  * - depsInstallActor: Check/install dependencies
  * - envCheckActor: Check environment variables
  * - supabaseStartActor: Start Supabase local
+ * - tablesManifestActor: Refresh tables.json from local Supabase
+ * - processCheckActor: Check for existing processes and port availability
  * - appStartActor: Start Next.js dev server
+ * - shutdownActor: Gracefully shut down dev server
  */
 export { depsInstallActor, envCheckActor, supabaseStartActor, } from '../../build/actors/setup.js';
+export { manifestActor } from '../../build/actors/manifest.js';
+export type { ManifestInput, ManifestOutput } from '../../build/actors/manifest.js';
+export { tablesManifestActor } from './tables-manifest.js';
+export type { TablesManifestInput, TablesManifestOutput } from './tables-manifest.js';
+export { processCheckActor } from './process-check.js';
+export type { ProcessCheckInput, ProcessCheckOutput } from './process-check.js';
+export { appStartActor, shutdownActor } from './app-lifecycle.js';
+export type { AppStartInput, AppStartOutput, ShutdownInput } from './app-lifecycle.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/dev/actors/process-check.d.ts

@@ -0,0 +1,12 @@
+export interface ProcessCheckInput {
+    repoRoot: string;
+    tmpDir: string;
+    port: number;
+    replace: boolean;
+    skipApp: boolean;
+}
+export interface ProcessCheckOutput {
+    staleProcessRecovered: boolean;
+}
+export declare const processCheckActor: import("xstate").PromiseActorLogic<ProcessCheckOutput, ProcessCheckInput, import("xstate").EventObject>;
+//# sourceMappingURL=process-check.d.ts.map

package/dist/commands/dev/actors/shared.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared utilities for dev actors.
+ */
+/** Minimal logger for process management (used by terminateAppProcessByPid) */
+export declare const consoleLogger: {
+    info: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    warn: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+};
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/dev/actors/tables-manifest.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AI HINT: Tables Manifest Refresh Actor
+ *
+ * Purpose: Refresh .runa/manifests/tables.json from the local Supabase database
+ * Pattern: Lightweight introspection refresh for `runa dev`
+ */
+export interface TablesManifestInput {
+    repoRoot: string;
+}
+export interface TablesManifestOutput {
+    passed: boolean;
+    durationMs: number;
+    error?: string;
+}
+export declare const tablesManifestActor: import("xstate").PromiseActorLogic<TablesManifestOutput, TablesManifestInput, import("xstate").EventObject>;
+//# sourceMappingURL=tables-manifest.d.ts.map

package/dist/commands/dev/contract.d.ts

@@ -22,8 +22,8 @@ export declare const DevInputSchema: z.ZodObject<{
     targetDir: z.ZodOptional<z.ZodString>;
     replace: z.ZodDefault<z.ZodBoolean>;
     bundler: z.ZodOptional<z.ZodEnum<{
-        turbopack: "turbopack";
         webpack: "webpack";
+        turbopack: "turbopack";
     }>>;
 }, z.core.$strict>;
 export type DevInput = z.infer<typeof DevInputSchema>;
@@ -31,11 +31,11 @@ export type DevInput = z.infer<typeof DevInputSchema>;
  * Status of a dev phase.
  */
 export declare const DevPhaseStatusSchema: z.ZodEnum<{
-    passed: "passed";
+    skipped: "skipped";
     failed: "failed";
     pending: "pending";
     running: "running";
-    skipped: "skipped";
+    passed: "passed";
 }>;
 export type DevPhaseStatus = z.infer<typeof DevPhaseStatusSchema>;
 /**

package/dist/commands/dev/guards.d.ts

@@ -18,9 +18,33 @@ export declare function shouldSkipDb({ context }: GuardParams): boolean;
  * Skipped when --skip-app is specified.
  */
 export declare function shouldSkipApp({ context }: GuardParams): boolean;
+/**
+ * Check if manifest generation should be skipped.
+ * Skipped when app startup is disabled or manifest generation is not applicable.
+ */
+export declare function shouldSkipManifest({ context }: GuardParams): boolean;
+/**
+ * Check if tables manifest refresh should be skipped.
+ * Skipped when app startup is disabled, DB setup is disabled, or Supabase is unavailable.
+ */
+export declare function shouldSkipTablesManifest({ context }: GuardParams): boolean;
+/**
+ * Check if an actor phase reported a failed result.
+ */
+export declare function phaseFailed({ event, }: {
+    event: {
+        output?: {
+            passed?: boolean;
+        };
+        [key: string]: unknown;
+    };
+}): boolean;
 export declare const guards: {
     shouldSkipDb: typeof shouldSkipDb;
     shouldSkipApp: typeof shouldSkipApp;
+    shouldSkipManifest: typeof shouldSkipManifest;
+    shouldSkipTablesManifest: typeof shouldSkipTablesManifest;
+    phaseFailed: typeof phaseFailed;
 };
 export {};
 //# sourceMappingURL=guards.d.ts.map

package/dist/commands/dev/machine.d.ts

@@ -11,7 +11,7 @@
  *
  * State Flow:
  * idle → START → processCheck → setup{depsInstall → envCheck → supabaseStart}
- *   → appStart → running → (STOP) → shutdown → done
+ *   → tablesManifest → manifest → appStart → running → (STOP) → shutdown → done
  * Any error → failed
  *
  * E2E Test Mapping (CLI observable behavior):
@@ -24,32 +24,8 @@
  * - failed → expect(exitCode).toBe(1)
  */
 import { type SnapshotFrom } from 'xstate';
+import type { ProcessCheckOutput } from './actors/index.js';
 import type { DevContext, DevInput } from './types.js';
-interface ProcessCheckInput {
-    repoRoot: string;
-    tmpDir: string;
-    port: number;
-    replace: boolean;
-    skipApp: boolean;
-}
-interface ProcessCheckOutput {
-    staleProcessRecovered: boolean;
-}
-interface AppStartInput {
-    repoRoot: string;
-    appDir: string;
-    port: number;
-    tmpDir: string;
-    stream: boolean;
-    bundler?: 'turbopack' | 'webpack';
-}
-interface AppStartOutput {
-    pid: number;
-    cleanupStreams: () => void;
-}
-interface ShutdownInput {
-    pid: number;
-}
 interface DevMachineInput {
     input?: Partial<DevInput>;
     repoRoot?: string;
@@ -62,8 +38,12 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
     type: "error.platform";
     error: Error;
 }, {
-    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<ProcessCheckOutput, ProcessCheckInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<AppStartOutput, AppStartInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, ShutdownInput, import("xstate").EventObject>> | undefined;
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/index.js").ManifestOutput, import("./actors/index.js").ManifestInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").EnvCheckOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("../build/actors/setup.js").SupabaseStartOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<ProcessCheckOutput, import("./actors/process-check.js").ProcessCheckInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/app-lifecycle.js").AppStartOutput, import("./actors/app-lifecycle.js").AppStartInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("./actors/app-lifecycle.js").ShutdownInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<import("./actors/tables-manifest.js").TablesManifestOutput, import("./actors/tables-manifest.js").TablesManifestInput, import("xstate").EventObject>> | undefined;
 }, {
+    src: "manifest";
+    logic: import("xstate").PromiseActorLogic<import("./actors/index.js").ManifestOutput, import("./actors/index.js").ManifestInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
     src: "depsInstall";
     logic: import("xstate").PromiseActorLogic<import("../build/actors/setup.js").DepsInstallOutput, import("../build/actors/setup.js").SetupInput, import("xstate").EventObject>;
     id: string | undefined;
@@ -77,24 +57,37 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
     id: string | undefined;
 } | {
     src: "processCheck";
-    logic: import("xstate").PromiseActorLogic<ProcessCheckOutput, ProcessCheckInput, import("xstate").EventObject>;
+    logic: import("xstate").PromiseActorLogic<ProcessCheckOutput, import("./actors/process-check.js").ProcessCheckInput, import("xstate").EventObject>;
     id: string | undefined;
 } | {
     src: "appStart";
-    logic: import("xstate").PromiseActorLogic<AppStartOutput, AppStartInput, import("xstate").EventObject>;
+    logic: import("xstate").PromiseActorLogic<import("./actors/app-lifecycle.js").AppStartOutput, import("./actors/app-lifecycle.js").AppStartInput, import("xstate").EventObject>;
     id: string | undefined;
 } | {
     src: "shutdown";
-    logic: import("xstate").PromiseActorLogic<void, ShutdownInput, import("xstate").EventObject>;
+    logic: import("xstate").PromiseActorLogic<void, import("./actors/app-lifecycle.js").ShutdownInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "tablesManifest";
+    logic: import("xstate").PromiseActorLogic<import("./actors/tables-manifest.js").TablesManifestOutput, import("./actors/tables-manifest.js").TablesManifestInput, import("xstate").EventObject>;
     id: string | undefined;
 }, never, {
     type: "shouldSkipDb";
     params: unknown;
+} | {
+    type: "shouldSkipManifest";
+    params: unknown;
 } | {
     type: "shouldSkipApp";
     params: unknown;
-}, never, "failed" | "running" | "done" | "idle" | "processCheck" | "appStart" | "shutdown" | {
-    setup: "depsInstall" | "envCheck" | "supabaseStart" | "done";
+} | {
+    type: "shouldSkipTablesManifest";
+    params: unknown;
+} | {
+    type: "phaseFailed";
+    params: unknown;
+}, never, "done" | "failed" | "manifest" | "running" | "idle" | "processCheck" | "appStart" | "shutdown" | "tablesManifest" | {
+    setup: "done" | "depsInstall" | "envCheck" | "supabaseStart";
 }, string, DevMachineInput, {
     success: boolean;
     exitCode: 0 | 1;
@@ -114,6 +107,8 @@ export declare const devMachine: import("xstate").StateMachine<DevContext, {
                 readonly done: {};
             };
         };
+        readonly tablesManifest: {};
+        readonly manifest: {};
         readonly appStart: {};
         readonly running: {};
         readonly shutdown: {};

package/dist/commands/dev/types.d.ts

@@ -20,6 +20,8 @@ export interface DevContext {
     tmpDir: string;
     /** Whether Supabase is configured */
     hasDatabase: boolean;
+    /** Whether manifest generation is applicable */
+    hasManifestTask: boolean;
     /** App process PID (when running) */
     appPid: number | null;
     /** Whether Supabase was started */

package/dist/commands/doctor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AI HINT: runa doctor
+ *
+ * Purpose: Deprecated alias for `runa check`
+ * Contract: JSON output must match `runa check`
+ */
+import { Command } from 'commander';
+export declare const doctorCommand: Command;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/env/commands/env-pull/auth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AI HINT: env pull auth helpers
+ *
+ * Purpose: Resolve Vercel auth and CLI prerequisites.
+ */
+import { execDotenvx } from '../../../../utils/dotenvx.js';
+import type { EnvPullLogger, EnvPullOptions, VercelAuth } from './shared.js';
+export declare function resolveVercelAuth(workDir: string, options: EnvPullOptions, logger: EnvPullLogger): VercelAuth;
+export declare function buildVercelCmdEnv(auth: VercelAuth): NodeJS.ProcessEnv;
+export declare function ensureVercelCli(): Promise<void>;
+export declare function ensureDotenvxCli(): Promise<void>;
+export { execDotenvx };
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/env/commands/env-pull/dotenv-files.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AI HINT: env pull file helpers
+ *
+ * Purpose: Manage .env files, local bootstrap replacement, and encryption keys.
+ */
+import type { EnvPullLogger, LocalBootstrapReport, VercelEnvironment } from './shared.js';
+export declare function missingLocalBootstrapReport(): LocalBootstrapReport;
+export declare function formatEnvValue(value: string): string;
+export declare function getOutputPath(workDir: string, environment: VercelEnvironment): string;
+export declare function extractAndSavePrivateKeys(workDir: string, envFiles: string[], logger: EnvPullLogger): boolean;
+export declare function removePrivateKeysFromEnvFile(filePath: string): void;
+export declare function replaceWithLocalValues(filePath: string, workDir: string, logger: EnvPullLogger, dryRun?: boolean): LocalBootstrapReport;
+export declare function encryptFile(workDir: string, filePath: string, logger: EnvPullLogger): Promise<boolean>;
+//# sourceMappingURL=dotenv-files.d.ts.map

package/dist/commands/env/commands/env-pull/security.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AI HINT: env pull security helpers
+ *
+ * Purpose: Path validation and error sanitization for env pull.
+ */
+import type { EnvPullLogger, EnvPullOptions } from './shared.js';
+export declare function sanitizeErrorMessage(message: string): string;
+export declare function containsPathTraversal(inputPath: string): boolean;
+export declare function isPathWithinBase(filePath: string, baseDir: string): boolean;
+export declare function validateCustomWorkingDir(cwdPath: string, projectRoot: string): string;
+export declare function resolveWorkingDir(options: EnvPullOptions, logger: EnvPullLogger): string;
+//# sourceMappingURL=security.d.ts.map

package/dist/commands/env/commands/env-pull/service.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AI HINT: env pull orchestration
+ *
+ * Purpose: Execute Vercel pull workflow while keeping the CLI entrypoint thin.
+ */
+import type { EnvPullActionResult, EnvPullOptions } from './shared.js';
+export declare function runEnvPullAction(options: EnvPullOptions): Promise<EnvPullActionResult>;
+//# sourceMappingURL=service.d.ts.map

package/dist/commands/env/commands/env-pull/shared.d.ts

@@ -0,0 +1,79 @@
+import type { createCLILogger } from '@runa-ai/runa';
+import { z } from 'zod';
+export type VercelEnvironment = 'development' | 'preview' | 'production';
+export interface EnvPullOptions {
+    environment?: VercelEnvironment;
+    app?: string;
+    cwd?: string;
+    encrypt: boolean;
+    token?: string;
+    project?: string;
+    org?: string;
+    productionAll?: boolean;
+    localhost?: boolean;
+    check?: boolean;
+}
+export interface PullResult {
+    environment: VercelEnvironment;
+    outputPath: string;
+    success: boolean;
+    encrypted?: boolean;
+    error?: string;
+}
+export type LocalBootstrapStatus = 'ok' | 'partial' | 'missing';
+export interface LocalBootstrapReport {
+    status: LocalBootstrapStatus;
+    missing: string[];
+}
+export interface VercelAuth {
+    method: 'env' | 'file';
+    token?: string;
+    projectId?: string;
+    orgId?: string;
+}
+export interface VercelSyncResult {
+    detected: boolean;
+    rootDirectory: string | null;
+    configUpdated: boolean;
+    reason?: string;
+}
+export interface EnvPullActionResult {
+    results: PullResult[];
+    totalPulled: number;
+    totalFailed: number;
+    totalEncrypted: number;
+    localBootstrap?: LocalBootstrapReport;
+    vercelSync?: VercelSyncResult;
+}
+export type EnvPullLogger = ReturnType<typeof createCLILogger>;
+export declare const EnvPullOutputSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        environment: z.ZodEnum<{
+            preview: "preview";
+            production: "production";
+            development: "development";
+        }>;
+        outputPath: z.ZodString;
+        success: z.ZodBoolean;
+        encrypted: z.ZodOptional<z.ZodBoolean>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    totalPulled: z.ZodNumber;
+    totalFailed: z.ZodNumber;
+    totalEncrypted: z.ZodOptional<z.ZodNumber>;
+    localBootstrap: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            ok: "ok";
+            missing: "missing";
+            partial: "partial";
+        }>;
+        missing: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    vercelSync: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        rootDirectory: z.ZodNullable<z.ZodString>;
+        configUpdated: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/env/commands/setup/types.d.ts

@@ -94,9 +94,9 @@ export declare const EnvSetupOutputSchema: z.ZodObject<{
         }>;
         success: z.ZodBoolean;
         action: z.ZodEnum<{
+            updated: "updated";
             skipped: "skipped";
             created: "created";
-            updated: "updated";
         }>;
         error: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;