@pyric/cli 0.1.0-alpha.30.1 → 0.1.0-alpha.31

package/src/serve/sandbox-session.ts

@@ -43,7 +43,9 @@ import {
 import { restoredStateCounts, stateForSummary } from './state-summary.js';
 import { parseStateFile } from './state-file.js';
 import { inlineStorage } from './state-objects.js';
+import type { AppPorts } from './app-ports.js';
 import { createHostedPersistence, formatStorageRepairs, type HostedPersistence } from './hosted/persistence.js';
+import type { GeminiProxyConfig } from './gemini-proxy.js';
 import {
   runProjectFixturesOnRulesReload,
   type RulesFixtureCheckSummary,
@@ -52,6 +54,8 @@ import {
 export interface SandboxSessionOptions {
   boundHost?: string;
   allowedHosts?: string[];
+  /** The app's ports under `pyric sandbox` (see `NamespaceOptions.appPorts`). */
+  appPorts?: AppPorts;
   flow?: FlowConfig;
   projectDir: string;
   firebaseConfig: FirebaseJson | null;
@@ -69,6 +73,8 @@ export interface SandboxSessionOptions {
   deployHostedRules?: (service: 'firestore' | 'database' | 'storage', source: string | null, instance?: DatabaseRulesDestination) => Promise<void>;
   ai?: InitPayload['ai'];
   aiProxyUpstream?: string;
+  /** The gemini engine the dev server's gemini proxy sends for a browser engine. */
+  aiGemini?: GeminiProxyConfig;
   /** Resolved `avatars` option (already reduced by `avatars-config.ts` from
    *  whatever the caller — the Vite plugin or `pyric sandbox` — accepted).
    *  Absent behaves like `{ enabled: false }`: no avatar route is mounted. */
@@ -212,7 +218,8 @@ export async function createSandboxSession(
 ): Promise<SandboxSession> {
   // Preserve the established fail-fast order: Firestore, then RTDB, then
   // Storage. Callers historically surfaced the first error in this sequence.
-  const firestore = await loadProjectRules(options.projectDir, options.firebaseConfig);
+  const firestore = await loadProjectRules(options.projectDir, options.firebaseConfig, options.project);
+  for (const warning of firestore.warnings) options.logger?.note(`  ⚠ ${warning}`);
   const database = await loadProjectDatabaseRules(options.projectDir, options.firebaseConfig, options.project);
   const storage = await loadProjectStorageRules(options.projectDir, options.firebaseConfig);
   // Each declared instance's rules in force, null while its file is missing.
@@ -423,6 +430,7 @@ export async function createSandboxSession(
     const namespace = createPyricNamespace({
       boundHost: options.boundHost,
       allowedHosts: options.allowedHosts,
+      appPorts: options.appPorts,
       indexes: createIndexConfigStore(options.projectDir),
       thresholds: createThresholdConfigStore(options.projectDir),
       rateCaptures: createRateCaptureStore(options.projectDir),
@@ -444,6 +452,7 @@ export async function createSandboxSession(
       workerVersion: options.sdk.workerVersion,
       avatars: avatarsResolver,
       aiProxyUpstream: options.aiProxyUpstream,
+      aiGemini: options.aiGemini,
       activity: options.activity,
       beacon: options.beacon,
       beaconToken: options.beaconToken,
@@ -453,9 +462,11 @@ export async function createSandboxSession(
     // Module files the latest failed reload asked for. Watched with the
     // last-good module files so fixing or creating one reloads.
     let attemptedModuleFiles: readonly string[] = [];
-    const firestoreSourcePath = firestoreRulesPath(options.projectDir, options.firebaseConfig);
+    const firestoreSourcePath = firestoreRulesPath(options.projectDir, options.firebaseConfig, options.project);
     const reloadFirestoreRules = async (): Promise<RulesReloadResult> => {
       const sourcePath = firestoreSourcePath;
+      // An array firebase.json that deploys no rules to (default) has no file to reload.
+      if (sourcePath === null) return { kind: 'not-configured' };
       const isSourceMissing = !existsSync(sourcePath);
       // A deleted source keeps the last-good rules. Without a rules file the
       // sandbox runs its default rules, which the SharedWorker sets to a
@@ -492,7 +503,8 @@ export async function createSandboxSession(
       }
     };
     const firestoreRulesFiles = (): readonly string[] => {
-      return [...new Set([firestoreSourcePath, ...firestore.moduleFiles, ...attemptedModuleFiles])];
+      const sourceFiles = firestoreSourcePath === null ? [] : [firestoreSourcePath];
+      return [...new Set([...sourceFiles, ...firestore.moduleFiles, ...attemptedModuleFiles])];
     };
     const databaseRulesFiles = (): readonly string[] => [...new Set([...database.targets, ...database.pending].map((target) => target.path))];
     // The Node host holds one store per instance, so each instance's rules

package/src/serve/server.ts

@@ -137,21 +137,43 @@ export function isAllowedOrigin(
   return originPort === expectedPort;
 }
 
+/**
+ * The Origin check once the app's ports are known: the Origin must name one of
+ * them. Both a page this app serves and a page on another local port are
+ * loopback, so only the port tells them apart. `undefined` means the ports
+ * are not known, and only the Origin's hostname is compared.
+ */
+function isAllowedOriginOnPorts(
+  originHeader: string | undefined,
+  boundHost: string,
+  extra: string[],
+  appPorts: readonly number[] | undefined,
+): boolean {
+  const portsUnknown = appPorts === undefined;
+  if (portsUnknown) return isAllowedOrigin(originHeader, boundHost, extra);
+  return appPorts.some((port) => isAllowedOrigin(originHeader, boundHost, extra, port));
+}
+
 /**
  * The combined guard for a WS `upgrade` request: BOTH the `Host` header
  * (DNS-rebinding) AND the `Origin` header (cross-origin hijack) must pass.
  * `upgrade` is a separate listener from the HTTP `request` event, so the
  * static server's request-time `isAllowedHost` never runs on it — every
  * upgrade mount point must call this before `wss.handleUpgrade`.
+ *
+ * Pass `appPorts` (the socket's `localPort`, plus any port `createAppPorts`
+ * learned) so a page on another local port is refused; without it only the
+ * Origin's hostname is compared.
  */
 export function isAllowedUpgrade(
   headers: { host?: string; origin?: string },
   boundHost: string,
   extra: string[] = [],
+  appPorts?: readonly number[],
 ): boolean {
   return (
     isAllowedHost(headers.host, boundHost, extra) &&
-    isAllowedOrigin(headers.origin, boundHost, extra)
+    isAllowedOriginOnPorts(headers.origin, boundHost, extra, appPorts)
   );
 }
 
@@ -208,17 +230,22 @@ export function isAllowedSessionToken(
 /**
  * Validates that an incoming HTTP request complies with both loopback Host
  * (DNS-rebinding) and Origin (cross-origin hijacking) restrictions.
+ *
+ * Pass `appPorts` (the socket's `localPort`, plus any port `createAppPorts`
+ * learned) so a page on another local port is refused; without it only the
+ * Origin's hostname is compared.
  */
 export function isAllowedLoopbackRequest(
   req: { headers?: IncomingHttpHeaders | Record<string, string | string[] | undefined> | Headers },
   boundHost: string,
   extra: string[] = [],
+  appPorts?: readonly number[],
 ): boolean {
   const hostHeader = getHeader(req, 'host');
   const originHeader = getHeader(req, 'origin');
   return (
     isAllowedHost(hostHeader, boundHost, extra) &&
-    isAllowedOrigin(originHeader, boundHost, extra)
+    isAllowedOriginOnPorts(originHeader, boundHost, extra, appPorts)
   );
 }
 

package/src/serve/vite-ai-config.ts

@@ -50,7 +50,6 @@ export function loadViteAiEnv(
     const isAuthKey =
       key === 'GEMINI_API_KEY' ||
       key === 'GOOGLE_GENAI_API_KEY' ||
-      key === 'VITE_GEMINI_API_KEY' ||
       key === 'PYRIC_API_KEY';
     if (isAuthKey && process.env[key] === undefined) {
       process.env[key] = val;
@@ -59,6 +58,25 @@ export function loadViteAiEnv(
   return loaded;
 }
 
+/** The Gemini key name Vite would serve to the browser. */
+const BROWSER_SERVED_GEMINI_KEY = 'VITE_GEMINI_API_KEY';
+
+/**
+ * Refuse a dev server whose environment or `.env` holds a Gemini key in
+ * `VITE_GEMINI_API_KEY`. Vite serves every `VITE_`-prefixed variable to the
+ * browser, so the key would reach every page the dev server serves (#1632).
+ * `env` is what `loadViteAiEnv` returned, which includes the shell's
+ * environment. A blank value holds no key and is left alone.
+ */
+export function refuseBrowserServedGeminiKey(env: Record<string, string | undefined>): void {
+  const value = env[BROWSER_SERVED_GEMINI_KEY];
+  const holdsKey = value !== undefined && value.trim() !== '';
+  if (!holdsKey) return;
+  throw new Error(
+    `@pyric/cli/vite: ${BROWSER_SERVED_GEMINI_KEY} is set. Vite serves every variable whose name starts with VITE_ to the browser, so this key would reach every page the dev server serves. Rename it to GEMINI_API_KEY in your environment or .env file. Pyric's dev server reads GEMINI_API_KEY and keeps it on the server.`,
+  );
+}
+
 /** Convert a public declarative engine into the JSON-safe worker wire shape. */
 export function engineConfigToWire(engine: PyricAiEngineConfig): AiEngineConfigWire {
   const isOpenAiEngine = engine.kind === 'openai';

package/src/serve/vite-functions-development.ts

@@ -1,19 +1,19 @@
 import type { Server } from 'node:http';
 import path from 'node:path';
 import type { ViteDevServer } from 'vite';
-import type { FunctionsRtdbProject } from '../functions-rtdb/project.js';
+import type { FunctionsProject } from '../functions/project.js';
 import {
   createFunctionsDevelopmentRuntime,
   createInProcessFunctionsPeerReadiness,
   type FunctionsDevelopmentEvent,
   type FunctionsDevelopmentResult,
   type FunctionsDevelopmentRuntime,
-} from '../functions-rtdb/development-runtime.js';
+} from '../functions/development-runtime.js';
 import type { BridgeMount } from './bridge-mount.js';
 
 export interface ViteFunctionsDevelopmentOptions {
   cwd: string;
-  project: FunctionsRtdbProject;
+  project: FunctionsProject;
   projectId: string;
   instance?: string;
   region?: string;

package/src/serve/vite-generation-bridge.ts

@@ -1,6 +1,6 @@
 import type { Server as HttpServer } from 'node:http';
 import type { ViteDevServer } from 'vite';
-import type { FunctionsRtdbProject } from '../functions-rtdb/project.js';
+import type { FunctionsProject } from '../functions/project.js';
 import type {
   BridgeHostAttachment,
   BridgeHostOptions,
@@ -19,7 +19,7 @@ export function createViteGenerationBridge(input: {
   projectDir: string;
   hosted?: boolean;
   options: Omit<BridgeMountOptions, 'upgradeGuard'> | null;
-  functionsProject: FunctionsRtdbProject | null;
+  functionsProject: FunctionsProject | null;
   functionsProjectId: string | null;
   createBridge(options: BridgeMountOptions): BridgeMount;
 }): BridgeMount | null {

package/src/serve/vite-generation-functions.ts

@@ -4,8 +4,8 @@ import path from 'node:path';
 import type { ViteDevServer } from 'vite';
 import type { FirebaseProjectResolution } from '../cli/firebase-project.js';
 import type {
-  FunctionsRtdbProject,
-} from '../functions-rtdb/project.js';
+  FunctionsProject,
+} from '../functions/project.js';
 import type { BridgeMount } from './bridge-mount.js';
 import type {
   ViteFunctionsDevelopmentAttachment,
@@ -14,7 +14,7 @@ import type {
 
 export interface ResolvedViteGenerationFunctions {
   options: { region?: string; instance?: string; watch?: boolean };
-  project: FunctionsRtdbProject | null;
+  project: FunctionsProject | null;
   projectId: string | null;
 }
 
@@ -25,7 +25,7 @@ export interface ResolvedViteGenerationFunctions {
 export function resolveViteGenerationFunctions(input: {
   projectDir: string;
   options: false | { region?: string; instance?: string; watch?: boolean };
-  discover(projectDir: string): FunctionsRtdbProject | null;
+  discover(projectDir: string): FunctionsProject | null;
   firebaseProject: FirebaseProjectResolution;
 }): ResolvedViteGenerationFunctions {
   const { projectDir, options, discover, firebaseProject } = input;
@@ -49,7 +49,7 @@ export function attachViteGenerationFunctions(input: {
 }): ViteFunctionsDevelopmentAttachment | null {
   const { server, projectDir, cliRoot, bridge, resolved, registerModuleUrl, attach } = input;
   if (!resolved.project || !resolved.projectId || !bridge || !server.httpServer) return null;
-  const builtChild = path.join(cliRoot, 'dist/functions-rtdb/child.js');
+  const builtChild = path.join(cliRoot, 'dist/functions/child.js');
   const fileExists = input.fileExists ?? existsSync;
   const childModuleUrl = fileExists(builtChild) ? builtChild : undefined;
   const host =

package/src/serve/vite-generation-middleware.ts

@@ -1,9 +1,28 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { ViteDevServer } from 'vite';
-import type { BridgeMount } from './bridge-mount.js';
+import { answerMountClosed, HEALTH_PATH, type BridgeMount } from './bridge-mount.js';
 import type { SandboxSession } from './sandbox-session.js';
 import { isAllowedHost } from './server.js';
 
+/** The request's path, from the URL before Connect stripped the `/__pyric` mount. */
+function requestPath(req: IncomingMessage & { originalUrl?: string }): string {
+  const raw = req.originalUrl ?? req.url ?? '/';
+  const queryAt = raw.indexOf('?');
+  return queryAt === -1 ? raw : raw.slice(0, queryAt);
+}
+
+/**
+ * Live generations per Connect stack. A restarted Vite server gets a new
+ * stack, so the old server's stack has none while its replacement starts. A
+ * plugin configured twice on one server stacks both generations, and the
+ * live one answers.
+ */
+const liveGenerations = new WeakMap<object, number>();
+
+function adjustLive(stack: object, by: number): void {
+  liveGenerations.set(stack, (liveGenerations.get(stack) ?? 0) + by);
+}
+
 /** Attach one generation's guarded namespace handler to Vite's permanent Connect stack. */
 export function attachViteGenerationMiddleware(input: {
   server: ViteDevServer;
@@ -12,12 +31,25 @@ export function attachViteGenerationMiddleware(input: {
 }): () => void {
   const { server, bridge, session } = input;
   const serverOptions = server.config.server;
+  const stack = server.middlewares;
   let active = true;
+  adjustLive(stack, 1);
 
   server.middlewares.use(
     '/__pyric',
     (req: IncomingMessage & { originalUrl?: string }, res: ServerResponse, next: () => void) => {
       if (!active) {
+        // With no live generation on this stack, a closed generation's mount
+        // still says it is closing, as the mount itself does once closed, so
+        // `pyric run --wait` waits for the restarted server instead of
+        // reading Vite's 404 as "not a host" (#1568).
+        const isHealthRequest = requestPath(req) === HEALTH_PATH;
+        const hasLiveGeneration = (liveGenerations.get(stack) ?? 0) > 0;
+        const answersClosing = bridge !== null && isHealthRequest && !hasLiveGeneration;
+        if (answersClosing) {
+          answerMountClosed(res);
+          return;
+        }
         next();
         return;
       }
@@ -52,5 +84,9 @@ export function attachViteGenerationMiddleware(input: {
     },
   );
 
-  return () => { active = false; };
+  return () => {
+    if (!active) return;
+    active = false;
+    adjustLive(stack, -1);
+  };
 }

package/src/serve/vite-module-swap.ts

@@ -20,6 +20,8 @@ import { loadServerTarget } from './vite-ssr-loader.js';
 
 const FIREBASE_SPECIFIER = /^firebase\/([a-z-]+(?:\/[a-z-]+)*)$/;
 const NODE_SHIM_PREFIX = '\0pyric:node-shim:';
+/** The SDK package the served entries import; one instance per page. */
+const PYRIC_PACKAGE = 'pyric';
 type OptimizerOptions = NonNullable<DepOptimizationOptions['esbuildOptions']>;
 type OptimizerPlugin = NonNullable<OptimizerOptions['plugins']>[number];
 
@@ -244,6 +246,12 @@ export function createViteModuleSwap(
         '@firebase/app-check',
         '@firebase/util',
         '@firebase/logger',
+        // A page's own `pyric/*` import would otherwise get a pre-bundled copy
+        // of pyric, with its own app registry, and the served entries would
+        // resolve to that copy too. The page and the entries must share the
+        // one pyric `initializeApp` registers apps in (#1506). The bare name
+        // covers every subpath.
+        PYRIC_PACKAGE,
       ];
       const usesRolldown = Number(viteVersion.split('.')[0]) >= 8;
       const optimizer = usesRolldown

package/src/serve/vite-page-runtime.ts

@@ -3,6 +3,7 @@ import type { ConfigEnv, UserConfig } from 'vite';
 import { SANDBOX_BUILD_META } from './sandbox-marker.js';
 import {
   loadViteAiEnv,
+  refuseBrowserServedGeminiKey,
   resolveViteAiConfig,
   type PyricAiOptions,
   type ResolvedViteAiConfig,
@@ -72,6 +73,11 @@ export function createVitePageRuntime(input: {
     config(config, env) {
       sandboxBuild = env.command === 'build';
       const loadedEnv = loadViteAiEnv(env.mode, config.root, config.envDir);
+      // Only the dev server serves `import.meta.env` to pages. A build's
+      // output and `vite preview`, which serves it, never held the key. The
+      // same condition as `isDevServer` in `vite-plugin.ts`.
+      const isDevServer = env.command === 'serve' && env.isPreview !== true;
+      if (isDevServer) refuseBrowserServedGeminiKey(loadedEnv);
       resolvedAi = resolveViteAiConfig(options.ai, loadedEnv);
       // The Vite dev server is the process `pyric sandbox` guards, and it
       // dials these destinations itself, so its guard must permit them.

package/src/serve/vite-rules-source.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import type { FirebaseJson } from '../cli/firebase-json.js';
+import { withDefaultFirestoreRules, type FirebaseJson } from '../cli/firebase-json.js';
 
 /**
  * Apply the Vite authoring convention without replacing unrelated Firebase
@@ -25,10 +25,7 @@ export function resolveViteRulesConfig(
     ...(firebaseConfig ?? {}),
   };
   if (firestoreSource) {
-    resolved.firestore = {
-      ...(firebaseConfig?.firestore ?? {}),
-      rules: firestoreSource,
-    };
+    resolved.firestore = withDefaultFirestoreRules(firebaseConfig?.firestore, firestoreSource);
   }
   if (storageSource) {
     const storage = firebaseConfig?.storage;

package/src/serve/vite-sandbox-generation.ts

@@ -5,9 +5,9 @@ import { readFirebaseJson, readFirebaseRc, type FirebaseJson } from '../cli/fire
 import { resolveFirebaseProject } from '../cli/firebase-project.js';
 import { registerModuleUrl } from '../cli/sandbox-runner.js';
 import {
-  discoverFunctionsRtdbProject,
-  type FunctionsRtdbProject,
-} from '../functions-rtdb/project.js';
+  discoverFunctionsProject,
+  type FunctionsProject,
+} from '../functions/project.js';
 import { formatActivityWarning } from './activity-warning.js';
 import { formatAiStatusNote } from './ai-status.js';
 import {
@@ -33,6 +33,7 @@ import { resolveAvatarsConfig, type PyricAvatarsOptions } from './avatars-config
 import { resolveViteRulesConfig } from './vite-rules-source.js';
 import type { ViteWorkerRuntime, ViteWorkerRuntimeStatus } from './vite-worker-runtime.js';
 import { viteWorkerEpochSalt } from './vite-ai-config.js';
+import { geminiProxyConfig } from './gemini-proxy.js';
 import {
   attachViteGenerationBridge,
   createViteGenerationBridge,
@@ -100,7 +101,7 @@ export interface ViteSandboxGenerationDependencies {
   resolveAvatarsConfig: typeof resolveAvatarsConfig;
   prepareWorker(runtime: ViteWorkerRuntime, epochSalt: string): Promise<void>;
   workerStatus(runtime: ViteWorkerRuntime): ViteWorkerRuntimeStatus;
-  discoverFunctionsProject(cwd: string): FunctionsRtdbProject | null;
+  discoverFunctionsProject(cwd: string): FunctionsProject | null;
   resolveSiteUiDir: typeof resolveSiteUiDir;
   createBridge(options: BridgeMountOptions): BridgeMount;
   createSession(options: SandboxSessionOptions): Promise<SandboxSession>;
@@ -117,7 +118,7 @@ const DEFAULT_DEPENDENCIES: ViteSandboxGenerationDependencies = {
   resolveAvatarsConfig,
   prepareWorker: (runtime, epochSalt) => runtime.prepare(epochSalt),
   workerStatus: (runtime) => runtime.status(),
-  discoverFunctionsProject: discoverFunctionsRtdbProject,
+  discoverFunctionsProject: discoverFunctionsProject,
   resolveSiteUiDir,
   createBridge: createBridgeMount,
   createSession: createSandboxSession,
@@ -278,6 +279,7 @@ export async function createViteSandboxGeneration(
       ai: aiOptions,
       avatars: avatarsConfig,
       aiProxyUpstream: ai.proxyUpstream,
+      aiGemini: geminiProxyConfig(ai.engineWire),
       activity: (incident) => server.config.logger.warn(formatActivityWarning(incident)),
       logger: {
         info: (message) => server.config.logger.info(message),