@runa-ai/runa-cli 0.5.44 → 0.5.45

package/dist/commands/ci/machine/machine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/machine/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AA8C1D,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAqB,MAAM,YAAY,CAAC;AAgBxE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAitCpB,CAAC;AAMH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAMxD;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAE3D"}
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/machine/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAU,KAAK,YAAY,EAAS,MAAM,QAAQ,CAAC;AA8C1D,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAqB,MAAM,YAAY,CAAC;AAexE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAymCpB,CAAC;AAMH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAMxD;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAE5D;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAE3D"}

package/dist/commands/ci/utils/app-runtime.d.ts

@@ -9,12 +9,20 @@ export declare function writeEnvLocal(params: {
     appDir: string;
     values: Record<string, string>;
 }): Promise<void>;
+/**
+ * App start mode:
+ * - 'dev': Development mode with hot reload (next dev)
+ * - 'start': Production mode (next start, requires build)
+ */
+export type AppMode = 'dev' | 'start';
 export declare function startAppBackground(params: {
     repoRoot: string;
     appDir: string;
     port: number;
     env: NodeJS.ProcessEnv;
     tmpDir: string;
+    /** App mode: 'dev' for development (hot reload), 'start' for production. Default: 'start' */
+    mode?: AppMode;
 }): Promise<{
     pid: number;
     cleanupStreams: () => void;

package/dist/commands/ci/utils/app-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-runtime.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/utils/app-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmGH,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB;AAwJD,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA0DvD;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB"}
+{"version":3,"file":"app-runtime.d.ts","sourceRoot":"","sources":["../../../../src/commands/ci/utils/app-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmGH,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMhB;AAiHD;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;AAwDtC,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,6FAA6F;IAC7F,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC,CA8DvD;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhB"}

package/dist/commands/db/utils/import-impact-analyzer.d.ts

@@ -1,5 +1,5 @@
 /**
- * AI HINT: Schema Import Impact Analyzer
+ * AI HINT: Schema Import Impact Analyzer (ts-morph based)
  *
  * Purpose: Analyze which files import schema tables/types and report impact
  * Usage: Used by `runa db sync --show-import-impact` to help developers
@@ -7,9 +7,15 @@
  *
  * Flow:
  * 1. Scan project for TypeScript files
- * 2. Find imports from database/schema packages
+ * 2. Use ts-morph AST to find imports from database/schema packages
  * 3. Map imported symbols to files
  * 4. Report which files would be affected by changes
+ *
+ * Why ts-morph (not regex):
+ * - Correctly handles comments containing 'import' keywords
+ * - Handles multi-line imports
+ * - Handles template literals and nested quotes
+ * - Per .claude/rules/code-quality.md: "Use AST (ts-morph) for TypeScript parsing"
  */
 export interface ImportReference {
     /** File path relative to project root */

package/dist/commands/db/utils/import-impact-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-impact-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/import-impact-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5C,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAkJD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAuBvE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,MAAM,EAAE,CAoCV"}
+{"version":3,"file":"import-impact-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/commands/db/utils/import-impact-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAC5C,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AA+JD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,CA8BvE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,GACxB,MAAM,EAAE,CAoCV"}

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

@@ -1 +1 @@
-{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAS1D,OAAO,KAAK,EAAE,UAAU,EAAY,QAAQ,EAAa,MAAM,YAAY,CAAC;AAsF5E,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAkCD,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIH,QAAQ;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EA6K5C,CAAC;AAMH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAM1D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAa1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAE7D"}
+{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/commands/dev/machine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAS1D,OAAO,KAAK,EAAE,UAAU,EAAY,QAAQ,EAAa,MAAM,YAAY,CAAC;AAsF5E,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAmCD,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;CACb;AAoBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAIH,QAAQ;cAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EA6K5C,CAAC;AAMH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC;AAC3C,MAAM,MAAM,WAAW,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,CAAC;AAM1D;;GAEG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAa1D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAE7D"}

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

@@ -1 +1 @@
-{"version":3,"file":"env-pull.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/commands/env-pull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAaH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA88BpC,eAAO,MAAM,WAAW,SA+BpB,CAAC"}
+{"version":3,"file":"env-pull.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/commands/env-pull.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAaH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAu9BpC,eAAO,MAAM,WAAW,SA+BpB,CAAC"}

package/dist/commands/env/constants/local-supabase.d.ts

@@ -1,18 +1,33 @@
 /**
  * AI HINT: Local Supabase Constants
  *
- * Purpose: Fixed values for local Supabase development (supabase start)
+ * Purpose: Dynamic values for local Supabase development (supabase start)
  * These are public, well-known values used by all Supabase CLI installations.
  *
  * Source: https://supabase.com/docs/guides/cli/local-development
  *
+ * Port Detection (Priority Order):
+ * 1. supabase/config.toml [api].port and [db].port settings
+ * 2. Default Supabase ports (54321 for API, 54322 for DB)
+ *
  * Note: These keys are intentionally public and NOT secrets.
  * They are the same for all local Supabase instances.
  */
+interface SupabasePorts {
+    api: number;
+    db: number;
+}
 /**
- * Local Supabase URL (default port: 54321)
+ * Detect Supabase ports from config.toml or use defaults.
+ *
+ * Priority:
+ * 1. supabase/config.toml settings
+ * 2. Default ports (54321/54322)
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Detected ports
  */
-export declare const LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+export declare function detectLocalSupabasePorts(projectRoot?: string): SupabasePorts;
 /**
  * Local Supabase anon key (fixed, public value)
  * This is the same for all local Supabase instances.
@@ -24,20 +39,57 @@ export declare const LOCAL_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpX
  */
 export declare const LOCAL_SUPABASE_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
 /**
- * Local PostgreSQL URL (default port: 54322)
- * User: postgres, Password: postgres (default local credentials)
+ * Build local Supabase URL from detected port.
  */
-export declare const LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+export declare function buildLocalSupabaseUrl(projectRoot?: string): string;
+/**
+ * Build local database URL from detected port.
+ */
+export declare function buildLocalDatabaseUrl(projectRoot?: string): string;
+/**
+ * Get map of environment variable keys to their local Supabase values.
+ *
+ * This function dynamically generates values based on detected ports.
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Environment variable key-value map
+ */
+export declare function getLocalSupabaseEnvValues(projectRoot?: string): Record<string, string>;
 /**
- * Map of environment variable keys to their local Supabase values
+ * Get human-readable descriptions for each local value (for summary display).
+ *
+ * @param projectRoot - Project root directory (defaults to process.cwd())
+ * @returns Description map
+ */
+export declare function getLocalValueDescriptions(projectRoot?: string): Record<string, string>;
+/**
+ * @deprecated Use getLocalSupabaseEnvValues() instead.
+ * This constant uses default ports; prefer the function for dynamic port detection.
  */
 export declare const LOCAL_SUPABASE_ENV_VALUES: Record<string, string>;
 /**
- * List of keys to replace with local values in .env.development
+ * @deprecated Use Object.keys(getLocalSupabaseEnvValues()) instead.
  */
 export declare const LOCAL_REPLACEMENT_KEYS: string[];
 /**
- * Human-readable descriptions for each local value (for summary display)
+ * @deprecated Use getLocalValueDescriptions() instead.
  */
 export declare const LOCAL_VALUE_DESCRIPTIONS: Record<string, string>;
+/**
+ * @deprecated Use buildLocalSupabaseUrl() instead.
+ */
+export declare const LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+/**
+ * @deprecated Use buildLocalDatabaseUrl() instead.
+ */
+export declare const LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+/**
+ * Validate that all URL values point to localhost.
+ * This prevents accidental production URL usage in local development.
+ *
+ * @param envValues - Environment values to validate
+ * @throws Error if any URL doesn't point to localhost
+ */
+export declare function validateLocalhostValues(envValues: Record<string, string>): void;
+export {};
 //# sourceMappingURL=local-supabase.d.ts.map

package/dist/commands/env/constants/local-supabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-supabase.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/constants/local-supabase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,uBAAuB,8JACyH,CAAC;AAE9J;;;GAGG;AACH,eAAO,MAAM,+BAA+B,yKAC4H,CAAC;AAEzK;;;GAGG;AACH,eAAO,MAAM,kBAAkB,4DAA4D,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAU5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAyC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAO3D,CAAC"}
+{"version":3,"file":"local-supabase.d.ts","sourceRoot":"","sources":["../../../../src/commands/env/constants/local-supabase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAgBH,UAAU,aAAa;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ;AA6DD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,GAAE,MAAsB,GAAG,aAAa,CAW3F;AAMD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,8JACyH,CAAC;AAE9J;;;GAGG;AACH,eAAO,MAAM,+BAA+B,yKAC4H,CAAC;AAEzK;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,CAGjF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,GAAE,MAAsB,GAAG,MAAM,CAGjF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,GAAE,MAAsB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,GAAE,MAAsB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxB;AAMD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA+B,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,sBAAsB,UAAyC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA+B,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,kBAAkB,2BAAyC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,kBAAkB,4DAAyE,CAAC;AAMzG;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAwB/E"}

package/dist/index.js

@@ -868,7 +868,7 @@ __export(types_exports, {
   calculateSummary: () => calculateSummary,
   createInitialContext: () => createInitialContext2,
   createOutput: () => createOutput4,
-  getErrorMessage: () => getErrorMessage2
+  getErrorMessage: () => getErrorMessage
 });
 function createInitialContext2(input3, repoRoot) {
   return {
@@ -915,7 +915,7 @@ function createOutput4(context) {
     durationMs
   };
 }
-function getErrorMessage2(error) {
+function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var init_types = __esm({
@@ -929,7 +929,7 @@ var CLI_VERSION, HAS_ADMIN_COMMAND;
 var init_version = __esm({
   "src/version.ts"() {
     init_esm_shims();
-    CLI_VERSION = "0.5.44";
+    CLI_VERSION = "0.5.45";
     HAS_ADMIN_COMMAND = false;
   }
 });
@@ -7787,33 +7787,38 @@ async function readPackageScripts(pkgPath) {
     return null;
   }
 }
-function determineStartCommand(isMonorepo2, rootScripts, appScripts, repoRoot, appDir, port) {
-  const rootHasStartCi = Boolean(rootScripts?.["start:ci"]);
-  const rootHasStart = Boolean(rootScripts?.start);
-  const appHasStartCi = Boolean(appScripts?.["start:ci"]);
-  const appHasStart = Boolean(appScripts?.start);
-  if (isMonorepo2 && (rootHasStartCi || rootHasStart)) {
-    const scriptName = rootHasStartCi ? "start:ci" : "start";
+function determineAppCommand(mode, isMonorepo2, rootScripts, appScripts, repoRoot, appDir, port) {
+  const ciScriptName = mode === "dev" ? "dev:ci" : "start:ci";
+  const defaultScriptName = mode;
+  const nextCommand = mode === "dev" ? "dev" : "start";
+  const rootHasCiScript = Boolean(rootScripts?.[ciScriptName]);
+  const rootHasDefaultScript = Boolean(rootScripts?.[defaultScriptName]);
+  const appHasCiScript = Boolean(appScripts?.[ciScriptName]);
+  const appHasDefaultScript = Boolean(appScripts?.[defaultScriptName]);
+  if (isMonorepo2 && (rootHasCiScript || rootHasDefaultScript)) {
+    const scriptName = rootHasCiScript ? ciScriptName : defaultScriptName;
     return { command: ["pnpm", scriptName], useRootScript: true };
   }
-  if (appHasStartCi || appHasStart) {
-    const scriptName = appHasStartCi ? "start:ci" : "start";
+  if (appHasCiScript || appHasDefaultScript) {
+    const scriptName = appHasCiScript ? ciScriptName : defaultScriptName;
     const dirArgs2 = isMonorepo2 ? ["-C", path10__default.relative(repoRoot, appDir)] : [];
     return { command: ["pnpm", ...dirArgs2, scriptName], useRootScript: false };
   }
   const dirArgs = isMonorepo2 ? ["-C", path10__default.relative(repoRoot, appDir)] : [];
   return {
-    command: ["pnpm", ...dirArgs, "exec", "next", "start", "-p", String(port)],
+    command: ["pnpm", ...dirArgs, "exec", "next", nextCommand, "-p", String(port)],
     useRootScript: false
   };
 }
 async function startAppBackground(params) {
+  const mode = params.mode ?? "start";
   const isMonorepo2 = params.appDir !== params.repoRoot;
   const rootPkgPath = path10__default.join(params.repoRoot, "package.json");
   const appPkgPath = path10__default.join(params.appDir, "package.json");
   const rootScripts = await readPackageScripts(rootPkgPath);
   const appScripts = isMonorepo2 ? await readPackageScripts(appPkgPath) : rootScripts;
-  const { command, useRootScript } = determineStartCommand(
+  const { command, useRootScript } = determineAppCommand(
+    mode,
     isMonorepo2,
     rootScripts,
     appScripts,
@@ -7824,8 +7829,10 @@ async function startAppBackground(params) {
   const appLog = path10__default.join(params.tmpDir, "app.log");
   const out = createWriteStream(appLog, { flags: "a" });
   const commandStr = command.join(" ");
+  const modeLabel = mode === "dev" ? "development (hot reload)" : "production";
   const logHeader = [
     `[runa] Starting app at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `[runa] Mode: ${modeLabel}`,
     `[runa] Command: ${commandStr}`,
     `[runa] Working directory: ${params.repoRoot}`,
     `[runa] App directory: ${path10__default.relative(params.repoRoot, params.appDir) || "."}`,
@@ -8000,7 +8007,8 @@ var appStartActor = fromPromise(
       appDir,
       port,
       env: process.env,
-      tmpDir: fullTmpDir
+      tmpDir: fullTmpDir,
+      mode: "dev"
     });
     await waitForAppReady({
       port,
@@ -14806,9 +14814,6 @@ function createOutput3(context) {
     error: context.error ?? void 0
   };
 }
-function getErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function extractErrorMessage2(event, fallbackMessage) {
   return event.error instanceof Error ? event.error.message : fallbackMessage;
 }
@@ -15034,7 +15039,6 @@ var ciMachine = setup({
       invoke: {
         src: "upsertComment",
         input: ({ context }) => {
-          console.log("[DEBUG] initialComment: Posting initial progress comment");
           const prNumber = context.prContext?.prNumber ?? 0;
           const progressInput = createProgressCommentInput(
             context,
@@ -15592,11 +15596,7 @@ ${generateProgressCommentBody(progressInput)}`;
             // Core tests failed - go to coreTestsFailed
             guard: ({ event }) => {
               const failedLayers = event.output.failedLayers ?? [];
-              const hasFailures = failedLayers.length > 0;
-              console.log(
-                `[DEBUG] runCoreTests.onDone guard: failedLayers=${JSON.stringify(failedLayers)}, hasFailures=${hasFailures}`
-              );
-              return hasFailures;
+              return failedLayers.length > 0;
             },
             target: "coreTestsFailed",
             actions: assign({
@@ -15605,9 +15605,6 @@ ${generateProgressCommentBody(progressInput)}`;
                 const results = event.output.results ?? [];
                 const failedLayers = event.output.failedLayers ?? [];
                 if (results.length === 0 && failedLayers.length > 0) {
-                  console.log(
-                    `[DEBUG] Converting failedLayers to layerResults: ${JSON.stringify(failedLayers)}`
-                  );
                   const layerResults = {};
                   for (const layer of failedLayers) {
                     layerResults[layer] = { status: "failed", exitCode: 1 };
@@ -15662,7 +15659,6 @@ ${generateProgressCommentBody(progressInput)}`;
       entry: assign({
         exitCode: ({ context }) => {
           if (Object.keys(context.layerResults).length === 0) {
-            console.log("[DEBUG] coreTestsFailed: layerResults is empty, returning exitCode=1");
             return 1;
           }
           return computeExitCodeFromLayerResults(context.layerResults);
@@ -15687,7 +15683,6 @@ ${generateProgressCommentBody(progressInput)}`;
           assertions: [{ type: "log", contains: "E2E phase" }]
         }
       },
-      entry: () => console.log("[DEBUG] Entering e2ePhase (parallel: comment + E2E tests)"),
       states: {
         // Sub-state 1: Post intermediate comment
         intermediateComment: {
@@ -15712,7 +15707,6 @@ ${generateProgressCommentBody(progressInput)}`;
               invoke: {
                 src: "upsertComment",
                 input: ({ context }) => {
-                  console.log("[DEBUG] e2ePhase.intermediateComment: Posting intermediate comment");
                   const prNumber = context.prContext?.prNumber ?? 0;
                   const commentInput = createCommentInput(context, {
                     isIntermediate: true,
@@ -15742,7 +15736,6 @@ ${generateCommentBody(commentInput)}`;
               invoke: {
                 src: "runLayers",
                 input: ({ context }) => {
-                  console.log("[DEBUG] e2ePhase.e2eTests: Running Layer 4");
                   const e2eBaseUrl = `http://localhost:${context.app?.port ?? 3e3}`;
                   return {
                     repoRoot: assertRepoRoot(context),
@@ -15768,9 +15761,6 @@ ${generateCommentBody(commentInput)}`;
                     // Merge E2E results into layerResults
                     layerResults: ({ context, event }) => {
                       const e2eResults = convertLayerResults(event.output.results);
-                      console.log(
-                        `[DEBUG] e2ePhase.e2eTests: E2E results=${JSON.stringify(e2eResults)}`
-                      );
                       return mergeLayerResults(context.layerResults, e2eResults);
                     }
                   })
@@ -15795,7 +15785,6 @@ ${generateCommentBody(commentInput)}`;
       onDone: {
         target: "finalize",
         actions: [
-          () => console.log("[DEBUG] e2ePhase complete, transitioning to finalize"),
           // Compute final exit code including E2E results
           assign({
             exitCode: ({ context }) => computeExitCodeFromLayerResults(context.layerResults)
@@ -15859,113 +15848,47 @@ ${generateCommentBody(commentInput)}`;
           }
         },
         postComment: {
-          entry: () => {
-            console.log("[DEBUG] Entering postComment state");
-          },
           always: [
             {
               // Skip if GitHub comment should not be posted (mode, env, flag checks)
-              guard: ({ context }) => {
-                const shouldPost = shouldPostGitHubComment(context);
-                const isCiPr = isCiPrMode(context);
-                console.log(
-                  `[DEBUG] postComment guard: shouldPost=${shouldPost}, isCiPr=${isCiPr}, mode=${context.mode}, env=${context.executionEnv}, skipFlag=${context.input.skipGithubComment}`
-                );
-                if (!shouldPost) {
-                  console.log(
-                    `[DEBUG] Skipping final comment: shouldPostGitHubComment=false (mode=${context.mode}, env=${context.executionEnv})`
-                  );
-                }
-                return !shouldPost;
-              },
+              guard: ({ context }) => !shouldPostGitHubComment(context),
               target: "complete"
             },
             {
               // Skip if PR number is not available (can't post without it)
-              guard: ({ context }) => {
-                const skip = !context.prContext?.prNumber;
-                if (skip) {
-                  console.log("[DEBUG] Skipping final comment: prNumber not available");
-                }
-                return skip;
-              },
+              guard: ({ context }) => !context.prContext?.prNumber,
               target: "complete"
             }
           ],
           invoke: {
             src: "upsertComment",
             input: ({ context }) => {
-              try {
-                const prNumber = assertPrNumber(context);
-                console.log(`[DEBUG] Posting final comment to PR #${prNumber}`);
-                const commentInput = createCommentInput(context);
-                const body = `<!-- runa-ci-report -->
+              const prNumber = assertPrNumber(context);
+              const commentInput = createCommentInput(context);
+              const body = `<!-- runa-ci-report -->
 ${generateCommentBody(commentInput)}`;
-                return {
-                  // repo is optional, resolved from environment inside actor
-                  issueNumber: prNumber,
-                  marker: "<!-- runa-ci-report -->",
-                  body
-                };
-              } catch (error) {
-                console.error(
-                  `[DEBUG] Failed to generate comment body: ${error instanceof Error ? error.message : String(error)}`
-                );
-                throw error;
-              }
-            },
-            onDone: {
-              target: "complete",
-              actions: ({ event }) => {
-                if (event.output.success) {
-                  console.log("[DEBUG] Final comment posted successfully");
-                } else {
-                  console.error(
-                    `[DEBUG] Failed to post final comment: ${event.output.error ?? "Unknown error"}`
-                  );
-                }
-              }
+              return {
+                issueNumber: prNumber,
+                marker: "<!-- runa-ci-report -->",
+                body
+              };
             },
-            onError: {
-              target: "complete",
-              actions: ({ event }) => {
-                console.error(
-                  `[DEBUG] postComment actor error: ${event.error instanceof Error ? event.error.message : String(event.error)}`
-                );
-              }
-            }
+            onDone: { target: "complete" },
+            onError: { target: "complete" }
           }
         },
         complete: {
-          entry: () => {
-            console.log("[DEBUG] Entered finalize.complete (final sub-state)");
-          },
           type: "final"
         }
       },
       onDone: [
-        {
-          guard: ({ context }) => context.exitCode !== 0,
-          target: "failed",
-          actions: () => {
-            console.log("[DEBUG] finalize.onDone -> failed");
-          }
-        },
-        {
-          target: "done",
-          actions: () => {
-            console.log("[DEBUG] finalize.onDone -> done");
-          }
-        }
+        { guard: ({ context }) => context.exitCode !== 0, target: "failed" },
+        { target: "done" }
       ],
       exit: [
-        // Stop the app if it was started
         ({ context }) => {
           if (context.appPid) {
-            stopApp(context.appPid).catch((error) => {
-              console.error(
-                `[DEBUG] Warning: Failed to stop app (pid: ${context.appPid}): ${getErrorMessage(error)}`
-              );
+            stopApp(context.appPid).catch(() => {
             });
           }
         }
@@ -15985,23 +15908,13 @@ ${generateCommentBody(commentInput)}`;
         }
       },
       type: "final",
-      entry: [
-        () => console.log("[DEBUG] Entered final state: done"),
-        // Safety: Ensure exitCode reflects actual layer results even if testsFailed was bypassed
-        assign({
-          durationMs: () => Date.now(),
-          exitCode: ({ context }) => {
-            if (context.exitCode !== 0) return context.exitCode;
-            const computed = computeExitCodeFromLayerResults(context.layerResults);
-            if (computed !== 0) {
-              console.log(
-                `[DEBUG] done state: Computing exitCode from layerResults: ${computed} (was ${context.exitCode})`
-              );
-            }
-            return computed;
-          }
-        })
-      ]
+      entry: assign({
+        durationMs: () => Date.now(),
+        exitCode: ({ context }) => {
+          if (context.exitCode !== 0) return context.exitCode;
+          return computeExitCodeFromLayerResults(context.layerResults);
+        }
+      })
     },
     failed: {
       meta: {
@@ -16015,14 +15928,10 @@ ${generateCommentBody(commentInput)}`;
       },
       type: "final",
       entry: [
-        ({ context }) => console.log(`[DEBUG] Entered final state: failed (exitCode=${context.exitCode})`),
-        // Preserve exit code from testsFailed if already set, otherwise compute
-        // If there's an error (actor failure), always return 1
         assign({
           exitCode: ({ context }) => context.exitCode !== 0 ? context.exitCode : context.error ? 1 : computeExitCodeFromLayerResults(context.layerResults),
           durationMs: () => Date.now()
         }),
-        // Stop the app if it was started
         ({ context }) => {
           if (context.appPid) {
             stopApp(context.appPid).catch(() => {
@@ -24905,13 +24814,12 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "__snapshots__"
 ]);
 var MAX_FILE_SIZE = 1024 * 1024;
-var SCHEMA_IMPORT_PATTERNS = [
-  /from\s+['"]@runa-ai\/runa-database\/schema['"]/,
-  /from\s+['"]@runa\/database\/schema['"]/,
-  /from\s+['"]@runa\/database['"]/,
-  /from\s+['"].*\/database\/src\/schema['"]/,
-  /from\s+['"].*\/packages\/database\/src\/schema['"]/
+var SCHEMA_IMPORT_SOURCES = [
+  "@runa-ai/runa-database/schema",
+  "@runa/database/schema",
+  "@runa/database"
 ];
+var SCHEMA_RELATIVE_PATTERNS = [/\/database\/src\/schema/, /\/packages\/database\/src\/schema/];
 function findTsFiles(dir, files = []) {
   if (!existsSync(dir)) return files;
   const entries = readdirSync(dir, { withFileTypes: true });
@@ -24929,75 +24837,80 @@ function findTsFiles(dir, files = []) {
   }
   return files;
 }
-function extractSchemaImports(filePath, rootDir) {
+function isSchemaImport(moduleSpecifier) {
+  if (SCHEMA_IMPORT_SOURCES.includes(moduleSpecifier)) {
+    return true;
+  }
+  return SCHEMA_RELATIVE_PATTERNS.some((pattern) => pattern.test(moduleSpecifier));
+}
+function extractSchemaImportsFromAST(sourceFile, rootDir) {
   const imports = [];
+  const filePath = sourceFile.getFilePath();
+  const relativeFilePath = relative(rootDir, filePath);
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (!isSchemaImport(moduleSpecifier)) {
+      continue;
+    }
+    const line = importDecl.getStartLineNumber();
+    const namedImports = importDecl.getNamedImports();
+    for (const namedImport of namedImports) {
+      const name = namedImport.getName();
+      const isTypeOnly = namedImport.isTypeOnly() || importDecl.isTypeOnly();
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: isTypeOnly ? `type ${name}` : name,
+        source: moduleSpecifier
+      });
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: `* as ${namespaceImport.getText()}`,
+        source: moduleSpecifier
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        file: relativeFilePath,
+        line,
+        symbol: `default (${defaultImport.getText()})`,
+        source: moduleSpecifier
+      });
+    }
+  }
+  return imports;
+}
+function extractSchemaImports(filePath, rootDir, project) {
   try {
     const stats = statSync(filePath);
     if (stats.size > MAX_FILE_SIZE) {
-      return imports;
-    }
-    const content = readFileSync(filePath, "utf-8");
-    const lines = content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const isSchemaImport = SCHEMA_IMPORT_PATTERNS.some((pattern) => pattern.test(line));
-      if (!isSchemaImport) continue;
-      const sourceMatch = line.match(/from\s+['"]([^'"]+)['"]/);
-      if (!sourceMatch) continue;
-      const source = sourceMatch[1];
-      const namedMatch = line.match(/import\s*\{([^}]+)\}/);
-      if (namedMatch) {
-        const symbols = namedMatch[1].split(",").map((s) => {
-          const parts = s.trim().split(/\s+as\s+/);
-          return parts[0].trim();
-        });
-        for (const symbol of symbols) {
-          if (symbol) {
-            imports.push({
-              file: relative(rootDir, filePath),
-              line: i + 1,
-              symbol,
-              source
-            });
-          }
-        }
-      }
-      const namespaceMatch = line.match(/import\s+\*\s+as\s+(\w+)/);
-      if (namespaceMatch) {
-        imports.push({
-          file: relative(rootDir, filePath),
-          line: i + 1,
-          symbol: `* as ${namespaceMatch[1]}`,
-          source
-        });
-      }
-      const typeMatch = line.match(/import\s+type\s*\{([^}]+)\}/);
-      if (typeMatch) {
-        const symbols = typeMatch[1].split(",").map(
-          (s) => s.trim().split(/\s+as\s+/)[0].trim()
-        );
-        for (const symbol of symbols) {
-          if (symbol) {
-            imports.push({
-              file: relative(rootDir, filePath),
-              line: i + 1,
-              symbol: `type ${symbol}`,
-              source
-            });
-          }
-        }
-      }
+      return [];
     }
+    const sourceFile = project.addSourceFileAtPath(filePath);
+    const imports = extractSchemaImportsFromAST(sourceFile, rootDir);
+    project.removeSourceFile(sourceFile);
+    return imports;
   } catch {
+    return [];
   }
-  return imports;
 }
 function analyzeImportImpact(rootDir) {
   const symbolUsage = /* @__PURE__ */ new Map();
   const tsFiles = findTsFiles(rootDir);
   let filesWithImports = 0;
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    skipFileDependencyResolution: true,
+    skipLoadingLibFiles: true
+  });
   for (const file of tsFiles) {
-    const imports = extractSchemaImports(file, rootDir);
+    const imports = extractSchemaImports(file, rootDir, project);
     if (imports.length > 0) {
       filesWithImports++;
     }
@@ -26209,30 +26122,84 @@ async function getVercelRootDirectory() {
 
 // src/commands/env/constants/local-supabase.ts
 init_esm_shims();
-var LOCAL_SUPABASE_URL = "http://127.0.0.1:54321";
+var DEFAULT_API_PORT = 54321;
+var DEFAULT_DB_PORT = 54322;
+function parsePortFromToml(content, section, key) {
+  const sectionRegex = new RegExp(`\\[${section}\\]([\\s\\S]*?)(?=\\n\\[|$)`, "g");
+  const sectionMatch = sectionRegex.exec(content);
+  if (!sectionMatch) return null;
+  const sectionContent = sectionMatch[1];
+  const keyRegex = new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, "m");
+  const keyMatch = keyRegex.exec(sectionContent);
+  if (!keyMatch) return null;
+  const port = Number.parseInt(keyMatch[1], 10);
+  return Number.isFinite(port) && port > 0 && port < 65536 ? port : null;
+}
+function readPortsFromConfigToml(projectRoot) {
+  const configPath = path10__default.join(projectRoot, "supabase", "config.toml");
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const apiPort = parsePortFromToml(content, "api", "port");
+    const dbPort = parsePortFromToml(content, "db", "port");
+    if (apiPort !== null || dbPort !== null) {
+      return {
+        api: apiPort ?? DEFAULT_API_PORT,
+        db: dbPort ?? DEFAULT_DB_PORT
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function detectLocalSupabasePorts(projectRoot = process.cwd()) {
+  const configPorts = readPortsFromConfigToml(projectRoot);
+  if (configPorts) {
+    return configPorts;
+  }
+  return {
+    api: DEFAULT_API_PORT,
+    db: DEFAULT_DB_PORT
+  };
+}
 var LOCAL_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0";
 var LOCAL_SUPABASE_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
-var LOCAL_DATABASE_URL = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
-var LOCAL_SUPABASE_ENV_VALUES = {
-  // Database URLs
-  DATABASE_URL: LOCAL_DATABASE_URL,
-  DATABASE_URL_ADMIN: LOCAL_DATABASE_URL,
-  DATABASE_URL_SERVICE: LOCAL_DATABASE_URL,
-  // Supabase URLs and keys
-  NEXT_PUBLIC_SUPABASE_URL: LOCAL_SUPABASE_URL,
-  NEXT_PUBLIC_SUPABASE_ANON_KEY: LOCAL_SUPABASE_ANON_KEY,
-  SUPABASE_SERVICE_ROLE_KEY: LOCAL_SUPABASE_SERVICE_ROLE_KEY
-};
-var LOCAL_REPLACEMENT_KEYS = Object.keys(LOCAL_SUPABASE_ENV_VALUES);
-var LOCAL_VALUE_DESCRIPTIONS = {
-  DATABASE_URL: "localhost:54322 (PostgreSQL)",
-  DATABASE_URL_ADMIN: "localhost:54322 (PostgreSQL)",
-  DATABASE_URL_SERVICE: "localhost:54322 (PostgreSQL)",
-  NEXT_PUBLIC_SUPABASE_URL: "localhost:54321 (Supabase API)",
-  NEXT_PUBLIC_SUPABASE_ANON_KEY: "local anon key (supabase-demo)",
-  SUPABASE_SERVICE_ROLE_KEY: "local service key (supabase-demo)"
-};
-function validateLocalhostValues() {
+function buildLocalSupabaseUrl(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return `http://127.0.0.1:${ports.api}`;
+}
+function buildLocalDatabaseUrl(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return `postgresql://postgres:postgres@127.0.0.1:${ports.db}/postgres`;
+}
+function getLocalSupabaseEnvValues(projectRoot = process.cwd()) {
+  const supabaseUrl = buildLocalSupabaseUrl(projectRoot);
+  const databaseUrl = buildLocalDatabaseUrl(projectRoot);
+  return {
+    // Database URLs
+    DATABASE_URL: databaseUrl,
+    DATABASE_URL_ADMIN: databaseUrl,
+    DATABASE_URL_SERVICE: databaseUrl,
+    // Supabase URLs and keys
+    NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: LOCAL_SUPABASE_ANON_KEY,
+    SUPABASE_SERVICE_ROLE_KEY: LOCAL_SUPABASE_SERVICE_ROLE_KEY
+  };
+}
+function getLocalValueDescriptions(projectRoot = process.cwd()) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  return {
+    DATABASE_URL: `localhost:${ports.db} (PostgreSQL)`,
+    DATABASE_URL_ADMIN: `localhost:${ports.db} (PostgreSQL)`,
+    DATABASE_URL_SERVICE: `localhost:${ports.db} (PostgreSQL)`,
+    NEXT_PUBLIC_SUPABASE_URL: `localhost:${ports.api} (Supabase API)`,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: "local anon key (supabase-demo)",
+    SUPABASE_SERVICE_ROLE_KEY: "local service key (supabase-demo)"
+  };
+}
+var LOCAL_SUPABASE_ENV_VALUES = getLocalSupabaseEnvValues();
+getLocalValueDescriptions();
+function validateLocalhostValues(envValues) {
   const urlKeys = [
     "DATABASE_URL",
     "DATABASE_URL_ADMIN",
@@ -26241,7 +26208,7 @@ function validateLocalhostValues() {
   ];
   const invalidEntries = [];
   for (const key of urlKeys) {
-    const value = LOCAL_SUPABASE_ENV_VALUES[key];
+    const value = envValues[key];
     if (value && !value.includes("127.0.0.1") && !value.includes("localhost")) {
       invalidEntries.push(key);
     }
@@ -26252,7 +26219,7 @@ function validateLocalhostValues() {
     );
   }
 }
-validateLocalhostValues();
+validateLocalhostValues(LOCAL_SUPABASE_ENV_VALUES);
 
 // src/commands/env/commands/env-pull.ts
 var ERROR_MESSAGES3 = {
@@ -26496,10 +26463,14 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
     logger16.warn("  \u26A0\uFE0F  No valid env vars found in .env.development (check syntax)");
     return;
   }
+  const projectRoot = process.cwd();
+  const localEnvValues = getLocalSupabaseEnvValues(projectRoot);
+  const localDescriptions = getLocalValueDescriptions(projectRoot);
+  const replacementKeys = Object.keys(localEnvValues);
   const replacedKeys = [];
-  for (const key of LOCAL_REPLACEMENT_KEYS) {
-    if (key in parsed && LOCAL_SUPABASE_ENV_VALUES[key]) {
-      parsed[key] = LOCAL_SUPABASE_ENV_VALUES[key];
+  for (const key of replacementKeys) {
+    if (key in parsed && localEnvValues[key]) {
+      parsed[key] = localEnvValues[key];
       replacedKeys.push(key);
     }
   }
@@ -26518,7 +26489,7 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
   if (dryRun) {
     logger16.info(`  \u{1F3E0} Would replace ${replacedKeys.length} variables with localhost values:`);
     for (const key of replacedKeys) {
-      const description = LOCAL_VALUE_DESCRIPTIONS[key] || "localhost";
+      const description = localDescriptions[key] || "localhost";
       logger16.info(`     ${key} \u2192 ${description}`);
     }
     logger16.info("  (dry-run: no files modified)");
@@ -26528,7 +26499,7 @@ function replaceWithLocalValues(filePath, logger16, dryRun = false) {
 `, "utf-8");
   logger16.success(`  \u{1F3E0} Replaced ${replacedKeys.length} variables with localhost values:`);
   for (const key of replacedKeys) {
-    const description = LOCAL_VALUE_DESCRIPTIONS[key] || "localhost";
+    const description = localDescriptions[key] || "localhost";
     logger16.info(`     ${key} \u2192 ${description}`);
   }
 }
@@ -31133,7 +31104,7 @@ function buildDefinitionMap(definitions) {
 function buildEnhancedMachines(e2eManifest, definitionMap, machineDefinitions) {
   const enhanced = {};
   const normalizedIdToCanonical = /* @__PURE__ */ new Map();
-  const isMachineFile = (path63) => path63.includes("machine.ts") || path63.includes("machines/") || path63.includes(".machine.ts") || path63.includes("/machine/");
+  const isMachineFile = (path64) => path64.includes("machine.ts") || path64.includes("machines/") || path64.includes(".machine.ts") || path64.includes("/machine/");
   const addMachine = (id, sourceFile, entryBuilder) => {
     const normalizedId = normalizeToCanonicalId(id).toLowerCase();
     const existingCanonical = normalizedIdToCanonical.get(normalizedId);
@@ -33729,9 +33700,9 @@ var PATH_MAPPING_RULES = [
     category: "prompts"
   }
 ];
-function getCategoryForPath(path63) {
+function getCategoryForPath(path64) {
   for (const rule of PATH_MAPPING_RULES) {
-    if (matchGlobPattern(path63, rule.runa) || matchGlobPattern(path63, rule.template)) {
+    if (matchGlobPattern(path64, rule.runa) || matchGlobPattern(path64, rule.template)) {
       return rule.category;
     }
   }
@@ -33751,17 +33722,17 @@ function applyReverseRename(normalized, rule, isTemplate) {
   }
   return normalized;
 }
-function generateComparisonKey(path63, isTemplate) {
-  let normalized = isTemplate ? normalizeTemplatePath(path63) : path63;
+function generateComparisonKey(path64, isTemplate) {
+  let normalized = isTemplate ? normalizeTemplatePath(path64) : path64;
   for (const rule of PATH_MAPPING_RULES) {
     normalized = applyReverseRename(normalized, rule, isTemplate);
   }
   return normalized;
 }
-function matchGlobPattern(path63, pattern) {
+function matchGlobPattern(path64, pattern) {
   const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<DOUBLE_STAR>>").replace(/\*/g, "([^/]*)").replace(/<<DOUBLE_STAR>>/g, "(.*)");
   const regex = new RegExp(`^${regexPattern}$`);
-  const match = path63.match(regex);
+  const match = path64.match(regex);
   if (match) {
     const subPath = match[1] ?? "";
     return { matched: true, subPath };
@@ -34123,7 +34094,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Discovery failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Discovery failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -34150,7 +34121,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Comparison failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Comparison failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -34174,7 +34145,7 @@ var syncCheckMachine = setup({
         onError: {
           target: "failed",
           actions: assign({
-            error: ({ event }) => `Report generation failed: ${getErrorMessage2(event.error)}`
+            error: ({ event }) => `Report generation failed: ${getErrorMessage(event.error)}`
           })
         }
       }
@@ -35733,7 +35704,7 @@ async function runVerification(logger16) {
 }
 async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
   const fs14 = await import('fs/promises');
-  const path63 = await import('path');
+  const path64 = await import('path');
   const { glob: glob8 } = await import('glob');
   const result = [];
   const packageJsonPaths = await glob8("**/package.json", {
@@ -35742,7 +35713,7 @@ async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
     // Exclude root
   });
   for (const relPath of packageJsonPaths) {
-    const fullPath = path63.join(rootDir, relPath);
+    const fullPath = path64.join(rootDir, relPath);
     try {
       const content = await fs14.readFile(fullPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -35755,7 +35726,7 @@ async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
       }
       if (hasAnySdkPackage) {
         result.push({
-          dir: path63.dirname(fullPath),
+          dir: path64.dirname(fullPath),
           packages: packageNames
           // All packages, not just found ones
         });
@@ -36398,7 +36369,7 @@ var SchemaWatcher = class {
       persistent: true,
       ignoreInitial: true
     });
-    this.watcher.on("add", (path63) => this.handleFileEvent("add", path63)).on("change", (path63) => this.handleFileEvent("change", path63)).on("unlink", (path63) => this.handleFileEvent("unlink", path63)).on("error", (error) => this.handleError(error));
+    this.watcher.on("add", (path64) => this.handleFileEvent("add", path64)).on("change", (path64) => this.handleFileEvent("change", path64)).on("unlink", (path64) => this.handleFileEvent("unlink", path64)).on("error", (error) => this.handleError(error));
     this.logger.success("\u2705 Schema watcher started");
     this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
   }
@@ -36419,23 +36390,23 @@ var SchemaWatcher = class {
   /**
    * Handle file system events with debouncing
    */
-  handleFileEvent(type, path63) {
-    const existingTimer = this.debounceTimers.get(path63);
+  handleFileEvent(type, path64) {
+    const existingTimer = this.debounceTimers.get(path64);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
     const timer = setTimeout(() => {
-      this.processFileEvent({ type, path: path63, timestamp: /* @__PURE__ */ new Date() });
-      this.debounceTimers.delete(path63);
+      this.processFileEvent({ type, path: path64, timestamp: /* @__PURE__ */ new Date() });
+      this.debounceTimers.delete(path64);
     }, this.options.debounceMs);
-    this.debounceTimers.set(path63, timer);
+    this.debounceTimers.set(path64, timer);
   }
   /**
    * Process file system event
    */
   async processFileEvent(event) {
-    const { type, path: path63 } = event;
-    const fileName = path63.split("/").pop() || path63;
+    const { type, path: path64 } = event;
+    const fileName = path64.split("/").pop() || path64;
     switch (type) {
       case "add":
         this.logger.info(chalk.green(`\u2795 Added: ${fileName}`));
@@ -36448,19 +36419,19 @@ var SchemaWatcher = class {
         return;
     }
     if (this.options.autoValidate) {
-      await this.validateFile(path63);
+      await this.validateFile(path64);
     }
   }
   /**
    * Validate schema file
    */
-  async validateFile(path63) {
+  async validateFile(path64) {
     try {
       this.logger.info(chalk.dim("  Validating..."));
-      const validationResult = await validateSchemaFile(path63);
+      const validationResult = await validateSchemaFile(path64);
       if (validationResult.isValid) {
         this.logger.success(chalk.green("  \u2713 Validation passed"));
-        const risks = await detectSchemaRisks(path63);
+        const risks = await detectSchemaRisks(path64);
         if (risks.length > 0) {
           this.logger.warn(`  \u26A0\uFE0F  ${risks.length} risk(s) detected`);
           for (const risk of risks) {
@@ -36475,7 +36446,7 @@ var SchemaWatcher = class {
         if (this.options.notifyOnError) {
           await notifyDesktop({
             title: "Schema Validation Failed",
-            message: `${validationResult.errors.length} error(s) in ${path63.split("/").pop()}`,
+            message: `${validationResult.errors.length} error(s) in ${path64.split("/").pop()}`,
             type: "error"
           });
         }
@@ -36694,7 +36665,7 @@ var TestWatcher = class {
       persistent: true,
       ignoreInitial: true
     });
-    this.watcher.on("add", (path63) => this.handleFileEvent("add", path63)).on("change", (path63) => this.handleFileEvent("change", path63)).on("unlink", (path63) => this.handleFileEvent("unlink", path63)).on("error", (error) => this.handleError(error));
+    this.watcher.on("add", (path64) => this.handleFileEvent("add", path64)).on("change", (path64) => this.handleFileEvent("change", path64)).on("unlink", (path64) => this.handleFileEvent("unlink", path64)).on("error", (error) => this.handleError(error));
     this.logger.success("\u2705 Test watcher started");
     this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
   }
@@ -36715,26 +36686,26 @@ var TestWatcher = class {
   /**
    * Handle file system events with debouncing
    */
-  handleFileEvent(type, path63) {
-    const existingTimer = this.debounceTimers.get(path63);
+  handleFileEvent(type, path64) {
+    const existingTimer = this.debounceTimers.get(path64);
     if (existingTimer) {
       clearTimeout(existingTimer);
     }
     const timer = setTimeout(() => {
-      this.processFileEvent(type, path63);
-      this.debounceTimers.delete(path63);
+      this.processFileEvent(type, path64);
+      this.debounceTimers.delete(path64);
     }, this.options.debounceMs);
-    this.debounceTimers.set(path63, timer);
+    this.debounceTimers.set(path64, timer);
   }
   /**
    * Process file system event
    */
-  async processFileEvent(type, path63) {
+  async processFileEvent(type, path64) {
     if (this.isRunning) {
       this.logger.warn(chalk.yellow("\u23F3 Tests already running, skipping..."));
       return;
     }
-    const fileName = path63.split("/").pop() || path63;
+    const fileName = path64.split("/").pop() || path64;
     switch (type) {
       case "add":
         this.logger.info(chalk.green(`\u2795 Test added: ${fileName}`));
@@ -36747,7 +36718,7 @@ var TestWatcher = class {
         return;
     }
     if (this.options.autoRun) {
-      await this.runTests(path63);
+      await this.runTests(path64);
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runa-ai/runa-cli",
-  "version": "0.5.44",
+  "version": "0.5.45",
   "private": false,
   "description": "AI-powered DevOps CLI",
   "type": "module",
@@ -53,8 +53,8 @@
     "typescript": "5.9.3",
     "xstate": "5.25.0",
     "zod": "4.3.5",
-    "@runa-ai/runa": "0.5.44",
-    "@runa-ai/runa-xstate-test-plugin": "0.5.35"
+    "@runa-ai/runa-xstate-test-plugin": "0.5.35",
+    "@runa-ai/runa": "0.5.44"
   },
   "engines": {
     "node": ">=20.0.0"