@pyric/cli 0.1.0-alpha.11 → 0.1.0-alpha.13

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

@@ -0,0 +1,28 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import type { FirebaseJson } from '../cli/firebase-json.js';
+
+/**
+ * Apply the Vite authoring convention without replacing unrelated Firebase
+ * configuration. The normal rules loader retains responsibility for its
+ * `firebase.json` and root `firestore.rules` fallbacks.
+ */
+export function resolveViteRulesConfig(
+  root: string,
+  explicitRules: string | undefined,
+  firebaseConfig: FirebaseJson | null,
+): FirebaseJson | null {
+  const rulesSource = explicitRules
+    ?? (existsSync(path.join(root, 'firestore.modules.rules'))
+      ? 'firestore.modules.rules'
+      : undefined);
+
+  if (!rulesSource) return firebaseConfig;
+  return {
+    ...(firebaseConfig ?? {}),
+    firestore: {
+      ...(firebaseConfig?.firestore ?? {}),
+      rules: rulesSource,
+    },
+  };
+}

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

@@ -0,0 +1,51 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  bundleWorker,
+  workerSourceHash,
+  type WorkerBundleOptions,
+  type WorkerBundleResult,
+} from './bundler.js';
+
+export interface ViteWorkerRuntimeStatus {
+  sdkDir: string;
+  ready: boolean;
+  epoch: string | null;
+}
+
+export interface ViteWorkerRuntime {
+  prepare(): Promise<void>;
+  status(): ViteWorkerRuntimeStatus;
+  headTag(marker: string): string;
+}
+
+interface ViteWorkerRuntimeOptions {
+  cacheRoot?: string;
+  cacheKey?: string;
+  bundle?: (options: WorkerBundleOptions) => Promise<WorkerBundleResult>;
+}
+
+/** Own the Vite plugin's worker build state and its one HTML projection. */
+export function createViteWorkerRuntime(
+  options: ViteWorkerRuntimeOptions = {},
+): ViteWorkerRuntime {
+  const cacheRoot = options.cacheRoot ?? join(homedir(), '.pyric', 'vite-worker');
+  const cacheKey = options.cacheKey ?? workerSourceHash();
+  const sdkDir = join(cacheRoot, cacheKey);
+  const bundle = options.bundle ?? bundleWorker;
+  let current: ViteWorkerRuntimeStatus = { sdkDir, ready: false, epoch: null };
+
+  return {
+    async prepare() {
+      current = { sdkDir, ready: false, epoch: null };
+      const result = await bundle({ outDir: sdkDir });
+      current = { sdkDir, ready: true, epoch: result.epoch };
+    },
+    status: () => current,
+    headTag(marker) {
+      return current.ready && current.epoch
+        ? `<meta name="pyric-worker-v" content="${current.epoch}" ${marker}>`
+        : `<script ${marker}>globalThis.__PYRIC_FORCE_INPAGE__=true;</script>`;
+    },
+  };
+}

package/src/serve/worker/activity-bootstrap.ts

@@ -0,0 +1,24 @@
+import type { ActivityMonitor } from 'pyric/firestore/internal';
+import { setupFirebaseActivityGuard as setupActivityGuardForFeed } from '../activity-guard.js';
+import type { HostCtx } from './host.js';
+
+export interface WorkerActivityEnv {
+  fetch: typeof fetch;
+}
+
+/** Own the worker-lifetime warning guard after capture history has hydrated. */
+export function setupFirebaseActivityGuard(
+  ctx: HostCtx,
+  env: WorkerActivityEnv,
+  activityToken: string | undefined,
+): ActivityMonitor | null {
+  if (!activityToken) return null;
+  return setupActivityGuardForFeed(
+    {
+      history: () => ctx.sandbox.history(),
+      subscribe: (listener) => ctx.sandbox.onEvent(listener),
+    },
+    env.fetch,
+    activityToken,
+  );
+}

package/src/serve/worker/client/admin-firestore.ts

@@ -0,0 +1,38 @@
+/**
+ * Admin-lens Firestore document ops over the worker port (Pyric Studio data
+ * browse) — rule-bypassing reads/writes the host resolves under the admin lens.
+ */
+
+import { nextId, rpc } from './core.js';
+import type { ClientDb } from './handles.js';
+
+export async function adminGetDocument(db: ClientDb, path: string): Promise<Record<string, unknown> | null> {
+  return (await rpc(db.port, { t: 'op', id: nextId(), method: 'admin.getDocument', path })) as Record<string, unknown> | null;
+}
+
+export async function adminListDocuments(
+  db: ClientDb,
+  path: string,
+): Promise<Array<{ path: string; data: unknown; phantom?: boolean }>> {
+  return (await rpc(db.port, { t: 'op', id: nextId(), method: 'admin.listDocuments', path })) as Array<{ path: string; data: unknown; phantom?: boolean }>;
+}
+
+export async function adminSetDocument(db: ClientDb, path: string, data: unknown): Promise<void> {
+  await rpc(db.port, { t: 'op', id: nextId(), method: 'admin.setDocument', path, data });
+}
+
+export async function adminDeleteDocument(db: ClientDb, path: string): Promise<boolean> {
+  return (await rpc(db.port, { t: 'op', id: nextId(), method: 'admin.deleteDocument', path })) as boolean;
+}
+
+export async function adminReadState(
+  db: ClientDb,
+  opts: { path?: string; maxDepth?: number } = {},
+): Promise<Record<string, unknown>> {
+  return (await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'admin.readState',
+    ...opts,
+  })) as Record<string, unknown>;
+}

package/src/serve/worker/client/ai.ts

@@ -0,0 +1,124 @@
+/**
+ * AI ops over the worker port — the served firebase/ai entry plugs these in
+ * as the mirror AnswerEngine on the worker path (see entries/ai.ts).
+ */
+
+import type { AiEngineConfigWire, InboundMessage } from '../protocol.js';
+import { closeSubscription, nextId, nextSubId, openSnapshotSubscription, rpc } from './core.js';
+import type { ClientDb } from './handles.js';
+
+// ─── AI ops (pyric/ai over the worker — cdd-deltas #98.3) ──────────────────
+//
+// The served `firebase/ai` entry (entries/ai.ts) plugs these three functions
+// in as the mirror's AnswerEngine on the worker path, so the page keeps the
+// full `pyric/ai` surface (GenerativeModel / ChatSession / Schema) while
+// ANSWERING happens in the worker host's broker — in-process with the ONE
+// shared sandbox (#98.1), whose unified event stream Studio consumes.
+// Requests/responses are the plain Gemini-wire JSON the broker speaks; no
+// codec round-trip. `engine` rides each message but is honored only on the
+// worker's FIRST ai op (broker creation — see AiEngineConfigWire).
+
+/** Parameters shared by the three AI ops. */
+export interface AiOpParams {
+  /** Model resource the mirror resolved (e.g. `models/gemini-flash-lite-latest`). */
+  model: string;
+  /** Plain Gemini-wire request JSON. */
+  request: Record<string, unknown>;
+  /** First-op engine config — see {@link AiEngineConfigWire}. */
+  engine?: AiEngineConfigWire;
+}
+
+/** Unary `generateContent` against the worker's broker. Resolves with the
+ *  complete WireResponse envelope; rejects with an Error carrying `.code`
+ *  (and `.aiEnvelope` when the broker answered a wire error envelope). */
+export async function aiGenerateContent(
+  db: ClientDb,
+  params: AiOpParams,
+): Promise<Record<string, unknown>> {
+  return (await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'ai.generateContent',
+    model: params.model,
+    request: params.request,
+    ...(params.engine !== undefined ? { engine: params.engine } : {}),
+  })) as Record<string, unknown>;
+}
+
+/** Unary `countTokens` against the worker's broker (deterministic). */
+export async function aiCountTokens(
+  db: ClientDb,
+  params: AiOpParams,
+): Promise<Record<string, unknown>> {
+  return (await rpc(db.port, {
+    t: 'op',
+    id: nextId(),
+    method: 'ai.countTokens',
+    model: params.model,
+    request: params.request,
+    ...(params.engine !== undefined ? { engine: params.engine } : {}),
+  })) as Record<string, unknown>;
+}
+
+/**
+ * Streamed `generateContent` over an AI stream SUBSCRIPTION: chunks arrive
+ * as `{ chunk }` snaps in order, the terminal `{ done: true }` snap ends the
+ * iteration, and a snap `__error` throws (with `.code` / `.aiEnvelope`).
+ * The host auto-unsubs on done; the generator additionally sends `unsub` on
+ * teardown so early consumer abandonment cancels the worker-side pump (the
+ * done/unsub race is a benign no-op on the host).
+ */
+export async function* aiStreamGenerateContent(
+  db: ClientDb,
+  params: AiOpParams,
+): AsyncGenerator<Record<string, unknown>> {
+  const subId = nextSubId();
+  type QueueItem =
+    | { kind: 'chunk'; chunk: Record<string, unknown> }
+    | { kind: 'done' }
+    | { kind: 'error'; error: unknown };
+  const queue: QueueItem[] = [];
+  let notify: (() => void) | null = null;
+  const push = (item: QueueItem): void => {
+    queue.push(item);
+    notify?.();
+    notify = null;
+  };
+
+  const opened = openSnapshotSubscription(db.port, subId, {
+    port: db.port,
+    next: (raw) => {
+      const v = (raw ?? {}) as { chunk?: Record<string, unknown>; done?: boolean };
+      if (v.done) push({ kind: 'done' });
+      else push({ kind: 'chunk', chunk: v.chunk ?? {} });
+    },
+    error: (err) => push({ kind: 'error', error: err }),
+  }, {
+    t: 'sub',
+    subId,
+    target: { service: 'ai', op: 'streamGenerateContent' },
+    model: params.model,
+    request: params.request,
+    ...(params.engine !== undefined ? { engine: params.engine } : {}),
+  } satisfies InboundMessage);
+  if (!opened) push({
+    kind: 'error',
+    error: Object.assign(new Error('Firebase App was deleted'), { code: 'app/app-deleted' }),
+  });
+
+  try {
+    for (;;) {
+      while (queue.length === 0) {
+        await new Promise<void>((resolve) => {
+          notify = resolve;
+        });
+      }
+      const item = queue.shift()!;
+      if (item.kind === 'error') throw item.error;
+      if (item.kind === 'done') return;
+      yield item.chunk;
+    }
+  } finally {
+    closeSubscription(db.port, subId);
+  }
+}