@k2b/cloud 0.23.0 → 0.25.0

package/src/ai/projects.ts

@@ -82,6 +82,7 @@ export type AiProjectAccess = {
   principal: Principal;
   permission: AiProjectPermission;
   displayName?: string;
+  avatarHash?: string | null;
   /** Kind of a `service_account` principal; presentation only. */
   serviceAccountKind?: ServiceAccountKind;
   createdAt: string;
@@ -157,6 +158,7 @@ type ProjectAccessRow = {
   permission: AiProjectPermission;
   created_at: Date | string;
   display_name: string | null;
+  avatar_hash: string | null;
   service_account_kind: ServiceAccountKind | null;
 };
 
@@ -260,6 +262,7 @@ const toProjectAccess = (row: ProjectAccessRow): AiProjectAccess => ({
           : { type: "public" },
   permission: row.permission,
   displayName: row.display_name ?? undefined,
+  ...(row.user_id ? { avatarHash: row.avatar_hash } : {}),
   serviceAccountKind: row.service_account_kind ?? undefined,
   createdAt: iso(row.created_at),
 });
@@ -290,9 +293,9 @@ const listProjectAccess = async (projectId: string, db: SQL = sql): Promise<AiPr
   const rows = await db<ProjectAccessRow[]>`
     SELECT project_access.short_id, access.user_id, access.group_id, access.service_account_id, access.authenticated_only,
            access.permission, access.created_at,
-           COALESCE(users.display_name, groups.name, service_accounts.name,
+           COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name,
              CASE WHEN access.authenticated_only THEN 'All authenticated users' ELSE 'Public' END) AS display_name,
-           service_accounts.kind AS service_account_kind
+           users.avatar_hash, service_accounts.kind AS service_account_kind
     FROM ai.project_access project_access
     JOIN auth.access access ON access.id = project_access.access_id
     LEFT JOIN auth.users users ON users.id = access.user_id

package/src/ai/runtime.ts

@@ -12,7 +12,6 @@ import { aiChatAccessSubject, selectAssistantAiModelId } from "./assistant-model
 import { startAiDictationRuntime } from "./dictation-runtime";
 import { AiTurnExecutor } from "./executor";
 import { canonicalizeAiConversationAttachments, snapshotAiConversationFiles } from "./file-context";
-import { startAiInvalidationRuntime, stopAiInvalidationRuntime } from "./live-outbox";
 import { drainQueuedMessages } from "./message-queue";
 import { aiQuotas } from "./quotas";
 import { parseAiResourceMarker } from "./resource-markers";
@@ -577,7 +576,6 @@ export const startAiRuntime = (
     },
   };
   running = state;
-  startAiInvalidationRuntime();
   log.info("AI runtime started", { workerId: AI_WORKER_ID, concurrency });
   return releaseAiRuntime(listener);
 };
@@ -591,10 +589,7 @@ const releaseAiRuntime = (listener: ((event: AiTurnFinalizedEvent) => Promise<vo
     if (!state) return;
     if (listener) state.listeners.delete(listener);
     refCount = Math.max(0, refCount - 1);
-    if (refCount === 0) {
-      state.stop();
-      void stopAiInvalidationRuntime();
-    }
+    if (refCount === 0) state.stop();
   };
 };
 

package/src/ai/skills.ts

@@ -58,6 +58,7 @@ export type AiSkillAccess = {
   principal: Principal;
   permission: AiSkillPermission;
   displayName?: string;
+  avatarHash?: string | null;
   /** Kind of a `service_account` principal; presentation only. */
   serviceAccountKind?: ServiceAccountKind;
   createdAt: string;
@@ -130,6 +131,7 @@ type SkillAccessRow = {
   permission: AiSkillPermission;
   created_at: Date | string;
   display_name: string | null;
+  avatar_hash: string | null;
   service_account_kind: ServiceAccountKind | null;
 };
 
@@ -284,9 +286,9 @@ const listSkillAccess = async (skillId: string, db: SQL = sql): Promise<AiSkillA
   const rows = await db<SkillAccessRow[]>`
     SELECT skill_access.short_id, access.user_id, access.group_id, access.service_account_id, access.authenticated_only,
            access.permission, access.created_at,
-           COALESCE(users.display_name, groups.name, service_accounts.name,
+           COALESCE(NULLIF(users.display_name, ''), users.uid, groups.name, service_accounts.name,
              CASE WHEN access.authenticated_only THEN 'All authenticated users' ELSE 'Public' END) AS display_name,
-           service_accounts.kind AS service_account_kind
+           users.avatar_hash, service_accounts.kind AS service_account_kind
     FROM ai.skill_access skill_access
     JOIN auth.access access ON access.id = skill_access.access_id
     LEFT JOIN auth.users users ON users.id = access.user_id
@@ -309,6 +311,7 @@ const listSkillAccess = async (skillId: string, db: SQL = sql): Promise<AiSkillA
             : { type: "public" },
     permission: row.permission,
     displayName: row.display_name ?? undefined,
+    ...(row.user_id ? { avatarHash: row.avatar_hash } : {}),
     serviceAccountKind: row.service_account_kind ?? undefined,
     createdAt: iso(row.created_at),
   }));

package/src/ai/solid.ts

@@ -7,11 +7,6 @@ export {
   createAiChatController,
 } from "./client/controller";
 export { conversationFileSource } from "./client/file-source";
-export {
-  type AiLiveConnection,
-  type CreateAiLiveConnectionOptions,
-  createAiLiveConnection,
-} from "./client/live-connection";
 export {
   type AiActiveTurn,
   type AiChatProjection,

package/src/ai/store.ts

@@ -4,6 +4,7 @@ import { type SQL, sql } from "bun";
 import { type CapabilityActionReview, CapabilityActionReviewSchema } from "../contracts/capabilities";
 import { logger } from "../services/logging";
 import { toPgTextArray } from "../services/postgres";
+import { AI_MEMORY_LEARNING_DEFAULT_ENABLED } from "./prefs";
 import type { AiTurnBlock } from "./protocol";
 import { withAiShortId, withAiShortIdForDb } from "./short-id";
 import { parseAiTodoPlan } from "./todo-contracts";
@@ -2801,6 +2802,19 @@ export const aiConversations: AiConversationService = {
             live_blocks = NULL
         WHERE id = ${input.turnId}
       `;
+      if (input.status === "completed") {
+        // Learning considers only turns that finish while it is on for the chat
+        // owner; turning it on later does not reach back to this turn.
+        await tx`
+          UPDATE ai.turns turn
+          SET memory_learned_at = turn.completed_at
+          FROM ai.conversations conversation
+          LEFT JOIN ai.user_prefs prefs ON prefs.user_id = conversation.created_by_user_id
+          WHERE turn.id = ${input.turnId}
+            AND conversation.id = turn.conversation_id
+            AND NOT COALESCE(prefs.memory_learning_enabled, ${AI_MEMORY_LEARNING_DEFAULT_ENABLED})
+        `;
+      }
       await tx`
         UPDATE ai.pending_actions
         SET status = 'aborted', resolved_at = COALESCE(resolved_at, now())

package/src/api/help.ts

@@ -8,7 +8,7 @@ import { helpApiMessages } from "./help-messages";
 export type HelpRouteDependencies = {
   help?: HelpReaderFactory;
   authenticate?: MiddlewareHandler<AuthContext>;
-  renderMarkdown?: (markdown: string) => string;
+  renderMarkdown?: (markdown: string, locale: string) => string;
 };
 
 export const createHelpRoutes = (dependencies: HelpRouteDependencies = {}) => {
@@ -34,7 +34,7 @@ export const createHelpRoutes = (dependencies: HelpRouteDependencies = {}) => {
         id: document.documentId,
         title: document.title,
         markdown: document.markdown,
-        html: (dependencies.renderMarkdown ?? renderHelpMarkdown)(document.markdown),
+        html: (dependencies.renderMarkdown ?? renderHelpMarkdown)(document.markdown, document.locale),
       };
       return c.json(payload);
     });

package/src/api/pwa-phone.ts

@@ -2,8 +2,8 @@ import { type Context, Hono } from "hono";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
 import { env } from "../config/env";
 import { PWA_AUTH_PATH, PWA_COOKIES, PWA_LIMITS, PWA_SCOPE, PwaClaimSchema, type PwaLaunchState, PwaRenameSchema } from "../contracts/pwa";
-import { type AuthContext, auth, rateLimit, v } from "../server";
-import { type PwaCredentials, PwaError, pwaDevices } from "../services/pwa-devices";
+import { type AuthContext, auth, getLocale, rateLimit, v } from "../server";
+import { type PwaCredentials, type PwaDeviceNotifier, PwaError, pwaDevices } from "../services/pwa-devices";
 import { defaultShellAvailable, handlePwaError, type PwaRouteOptions, pwaErrorResponse, pwaInvalidRequest, pwaTransport } from "./pwa";
 
 const PAIRING_COOKIE_PATH = `${PWA_AUTH_PATH}/pairings`;
@@ -58,12 +58,17 @@ export const launchTarget = (to: string | undefined): string => {
 
 const stateUrl = (state: PwaLaunchState) => `${PWA_SCOPE}?pwa=${state}`;
 
+export type PwaPhoneRouteOptions = PwaRouteOptions & {
+  /** Sends the "new phone paired" notice; completion awaits it before the phone gets its credentials. */
+  notify: PwaDeviceNotifier;
+};
+
 /**
  * Phone side of the mobile app (preview), mounted by Core at `/pwa/_auth` before its page
  * catch-all. The device key and the completion secret use cookie paths below `/pwa/_auth`,
  * which only Core serves; other applications see only the 24-hour app session.
  */
-export const createPwaPhoneRoutes = (options: PwaRouteOptions = {}) => {
+export const createPwaPhoneRoutes = (options: PwaPhoneRouteOptions) => {
   const service = options.service ?? pwaDevices;
   const shellAvailable = options.shellAvailable ?? defaultShellAvailable;
   const limit = rateLimit({ keyBy: "ip" });
@@ -102,6 +107,8 @@ export const createPwaPhoneRoutes = (options: PwaRouteOptions = {}) => {
           deviceKey: getCookie(c, PWA_COOKIES.device),
           appSession: await appSession(c),
           webUserId: web?.user.id ?? null,
+          locale: getLocale(c),
+          notify: options.notify,
         });
         if (result.state === "waiting") return c.json(result, 202);
         if (result.credentials) setAppCredentials(c, result.credentials);

package/src/api/search/schemas.ts

@@ -85,6 +85,40 @@ export const SearchResponseSchema = z.object({
   failedApps: z.array(z.string()).optional(),
 });
 
+/** Media type a client sends in `Accept` to receive one NDJSON line per app as soon as it finishes. */
+export const SEARCH_STREAM_CONTENT_TYPE = "application/x-ndjson";
+
+export const SearchProviderStatusSchema = z.enum(["ok", "empty", "timeout", "error"]);
+
+/**
+ * One line of a streamed search: `start` names the apps that search, one `provider` line follows per app in the
+ * order the apps finish, and `done` closes the search. Apps without a line before `done` do not exist: every app
+ * named in `start` gets exactly one line.
+ */
+export const SearchStreamLineSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("start"),
+    query: z.string(),
+    apps: z.array(SearchAppSchema),
+    providers: z.array(z.string()),
+    unsupportedTags: z.array(z.string()).optional(),
+  }),
+  z.object({
+    type: z.literal("provider"),
+    provider: z.string(),
+    status: SearchProviderStatusSchema,
+    results: z.array(SearchItemSchema),
+    ms: z.number().int().nonnegative(),
+  }),
+  z.object({
+    type: z.literal("done"),
+    status: z.enum(["complete", "partial"]),
+    count: z.number().int().nonnegative(),
+  }),
+]);
+
 export type SearchApp = z.infer<typeof SearchAppSchema>;
 export type SearchItem = z.infer<typeof SearchItemSchema>;
 export type SearchResponse = z.infer<typeof SearchResponseSchema>;
+export type SearchProviderStatus = z.infer<typeof SearchProviderStatusSchema>;
+export type SearchStreamLine = z.infer<typeof SearchStreamLineSchema>;

package/src/api/search.ts

@@ -1,5 +1,5 @@
 import { Hono, type MiddlewareHandler } from "hono";
-import { describeRoute } from "hono-openapi";
+import { describeRoute, resolver } from "hono-openapi";
 import { readBoundedJson } from "../_internal/bounded-json";
 import { resolveCapabilityManifestPresentation } from "../_internal/capabilities";
 import { listCapabilities } from "../_internal/registry";
@@ -18,14 +18,24 @@ import { searchInvocationOperation } from "../services/identity/invocation-opera
 import { normalizeInvocationRequestId, signInvocationToken } from "../services/identity/invocation-token";
 import { withActiveIdentitySigner } from "../services/identity/key-ring";
 import { LOCALE_HEADER } from "../shared/locale";
-import { type SearchItem, SearchItemSchema, SearchQuerySchema, SearchResponseSchema } from "./search/schemas";
+import {
+  SEARCH_STREAM_CONTENT_TYPE,
+  type SearchItem,
+  SearchItemSchema,
+  type SearchProviderStatus,
+  SearchQuerySchema,
+  type SearchResponse,
+  SearchResponseSchema,
+  type SearchStreamLine,
+  SearchStreamLineSchema,
+} from "./search/schemas";
 
 const log = logger("search");
 const SearchProviderResultSchema = capabilityResultSchema(UniversalSearchDataSchema);
 
 /**
- * Maximum items returned to the client after merging across providers.
- * The frontend has no further limit — this caps the rendered list.
+ * Maximum items of the merged JSON response. A streamed search has no merged
+ * list: each app's line carries at most that app's provider limit.
  */
 const GLOBAL_RESULT_LIMIT = 30;
 const PROVIDER_CONCURRENCY = 8;
@@ -122,8 +132,25 @@ const startBounded = <T, R>(
   return deferred.map((entry) => entry.promise);
 };
 
-const settleBounded = async <T, R>(items: readonly T[], concurrency: number, run: (item: T, index: number) => Promise<R>) =>
-  Promise.all(startBounded(items, concurrency, run));
+/** Highest app-provided priority first, then by title. */
+const rankItems = (items: SearchItem[]) => items.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0) || a.title.localeCompare(b.title));
+
+/** The browser asks for a stream explicitly; every other client keeps the merged JSON response. */
+const acceptsStream = (accept: string | undefined) =>
+  accept?.split(",").some((type) => type.split(";")[0]?.trim().toLowerCase() === SEARCH_STREAM_CONTENT_TYPE) ?? false;
+
+const streamHeaders = {
+  "content-type": `${SEARCH_STREAM_CONTENT_TYPE}; charset=utf-8`,
+  // Each line must reach the browser when it is written: no cache, no transformation, no proxy buffering.
+  "cache-control": "no-store, no-transform",
+  "x-accel-buffering": "no",
+} as const;
+
+const encoder = new TextEncoder();
+const lineText = (line: SearchStreamLine) => `${JSON.stringify(line)}\n`;
+const encodeLine = (line: SearchStreamLine) => encoder.encode(lineText(line));
+
+type AppOutcome = { appId: string; status: SearchProviderStatus; items: SearchItem[]; ms: number };
 
 const waitWithin = <T>(value: Promise<T>, signal: AbortSignal): Promise<T> =>
   new Promise<T>((resolve, reject) => {
@@ -160,7 +187,14 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
       description: "Searches across app providers discovered via the service registry with optional tag filters.",
       ...requiresAuth,
       responses: {
-        200: jsonResponse(SearchResponseSchema, "Merged search results"),
+        200: {
+          description:
+            "Merged search results. With `Accept: application/x-ndjson`, one JSON line per app in the order the apps finish instead.",
+          content: {
+            "application/json": { schema: resolver(SearchResponseSchema) },
+            [SEARCH_STREAM_CONTENT_TYPE]: { schema: resolver(SearchStreamLineSchema) },
+          },
+        },
         400: jsonResponse(ErrorResponseSchema, "Invalid query"),
         401: jsonResponse(ErrorResponseSchema, "Authentication required"),
         403: jsonResponse(ErrorResponseSchema, "User-backed actor required"),
@@ -172,6 +206,7 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
       expectUserBackedActor(c);
 
       const query = c.req.valid("query");
+      const stream = acceptsStream(c.req.header("accept"));
       const requestId = normalizeInvocationRequestId(c.req.header("x-request-id"));
       const invocationAuthority = invocationAuthorityFromRequest(auth.getAuthority(c));
       let entries: CapabilityRegistryEntry[];
@@ -231,18 +266,24 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
       const active =
         query.tag.length === 0 ? appProviders : appProviders.filter((provider) => provider.tags.some((tag) => query.tag.includes(tag)));
 
+      // Answers without a provider call: the catalog alone, or only unsupported tags.
+      const answerWithoutProviders = (body: SearchResponse) =>
+        stream
+          ? new Response(
+              [
+                lineText({ type: "start", query: body.query, apps, providers: [], ...(body.unsupportedTags ? { unsupportedTags } : {}) }),
+                lineText({ type: "done", status: "complete", count: 0 }),
+              ].join(""),
+              { headers: streamHeaders },
+            )
+          : c.json(body);
+
       if (query.q.length === 0 && query.tag.length === 0 && !query.app && !scope) {
-        return c.json({ query: "", count: 0, items: [], apps });
+        return answerWithoutProviders({ query: "", count: 0, items: [], apps });
       }
 
       if (query.tag.length > 0 && active.length === 0) {
-        return c.json({
-          query: query.q,
-          count: 0,
-          items: [],
-          apps,
-          unsupportedTags,
-        });
+        return answerWithoutProviders({ query: query.q, count: 0, items: [], apps, unsupportedTags });
       }
 
       // Single-provider queries get a larger sample for better local
@@ -252,7 +293,9 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
       const effectiveProviderLimit = active.length === 1 ? Math.min(GLOBAL_RESULT_LIMIT, query.provider_limit * 3) : query.provider_limit;
       // The same request-wide budget covers signing and provider I/O.
       const providerDeadline = AbortSignal.timeout(PROVIDER_TIMEOUT_MS);
-      const fanoutSignal = AbortSignal.any([c.req.raw.signal, providerDeadline]);
+      // A client that stops reading a stream, such as the browser on the next keystroke, ends the search too.
+      const streamCancelled = new AbortController();
+      const fanoutSignal = AbortSignal.any([c.req.raw.signal, providerDeadline, streamCancelled.signal]);
       // Guard the whole issuance batch once, then reuse the prepared signer for
       // every target. This is one Postgres check per outer search request, not
       // one check per provider.
@@ -298,7 +341,8 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
       // One request-wide budget keeps latency flat as the number of apps grows.
       // Workers that have not started when the deadline expires fail fast on
       // the already-aborted signal instead of opening a fresh timeout window.
-      const settled = await settleBounded(active, PROVIDER_CONCURRENCY, async (provider, index) => {
+      const fanoutStarted = performance.now();
+      const settled = startBounded(active, PROVIDER_CONCURRENCY, async (provider, index) => {
         // Scope tags to those this provider declared. Apps no longer need
         // their own gate — the framework guarantees they only see tags
         // they understand.
@@ -395,47 +439,71 @@ export const createSearchRoutes = (dependencies: SearchRouteDependencies = {}) =
         return validItems;
       });
 
-      const items = settled.flatMap((result, index) => {
-        if (result.status === "fulfilled") return result.value;
-
-        log.warn("Search provider failed", {
-          appId: active[index]?.appId ?? "unknown",
-          tags: query.tag,
-          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-        });
-        return [];
+      // One outcome per app, when all of its Queries have finished. Multiple
+      // focused Queries from one app must not buy that app a larger share.
+      const appIds = [...new Set(active.map((provider) => provider.appId))];
+      const outcomes = appIds.map(async (appId): Promise<AppOutcome> => {
+        const results = await Promise.all(active.flatMap((provider, index) => (provider.appId === appId ? [settled[index]!] : [])));
+        const failed = results.filter((result) => result.status === "rejected");
+        for (const result of failed) {
+          log.warn("Search provider failed", {
+            appId,
+            tags: query.tag,
+            error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+          });
+        }
+        const items = rankItems(results.flatMap((result) => (result.status === "fulfilled" ? result.value : []))).slice(
+          0,
+          effectiveProviderLimit,
+        );
+        const status = failed.length ? (providerDeadline.aborted ? "timeout" : "error") : items.length ? "ok" : "empty";
+        return { appId, status, items, ms: Math.round(performance.now() - fanoutStarted) };
       });
+      const failure = (outcome: AppOutcome) => outcome.status === "timeout" || outcome.status === "error";
 
-      items.sort((a, b) => {
-        const priorityDiff = (b.priority ?? 0) - (a.priority ?? 0);
-        if (priorityDiff !== 0) return priorityDiff;
-        return a.title.localeCompare(b.title);
-      });
+      if (stream) {
+        let cancelled = false;
+        const body = new ReadableStream<Uint8Array>({
+          start(controller) {
+            const write = (line: SearchStreamLine) => {
+              if (!cancelled) controller.enqueue(encodeLine(line));
+            };
+            write({ type: "start", query: query.q, apps, providers: appIds, ...(unsupportedTags.length > 0 ? { unsupportedTags } : {}) });
+            let count = 0;
+            let partial = false;
+            // A slow app never holds back the others: each line is written when its app finishes.
+            void Promise.all(
+              outcomes.map((pending) =>
+                pending.then((outcome) => {
+                  count += outcome.items.length;
+                  partial ||= failure(outcome);
+                  write({ type: "provider", provider: outcome.appId, status: outcome.status, results: outcome.items, ms: outcome.ms });
+                }),
+              ),
+            ).then(() => {
+              write({ type: "done", status: partial ? "partial" : "complete", count });
+              if (!cancelled) controller.close();
+            });
+          },
+          cancel() {
+            cancelled = true;
+            streamCancelled.abort();
+          },
+        });
+        return new Response(body, { headers: streamHeaders });
+      }
 
-      // Multiple focused Queries from one app must not buy that app a larger
-      // share of the merged result set.
-      const appCounts = new Map<string, number>();
-      const appBounded = items.filter((item) => {
-        const count = appCounts.get(item.appId) ?? 0;
-        if (count >= effectiveProviderLimit) return false;
-        appCounts.set(item.appId, count + 1);
-        return true;
-      });
-      const sliced = appBounded.slice(0, GLOBAL_RESULT_LIMIT);
+      const finished = await Promise.all(outcomes);
+      const items = rankItems(finished.flatMap((outcome) => outcome.items)).slice(0, GLOBAL_RESULT_LIMIT);
+      const failedApps = finished.filter(failure).map((outcome) => outcome.appId);
 
       return c.json({
         query: query.q,
-        count: sliced.length,
-        items: sliced,
+        count: items.length,
+        items,
         apps,
         ...(unsupportedTags.length > 0 ? { unsupportedTags } : {}),
-        ...(settled.some((result) => result.status === "rejected")
-          ? {
-              failedApps: [
-                ...new Set(active.filter((_, index) => settled[index]?.status === "rejected").map((provider) => provider.appId)),
-              ],
-            }
-          : {}),
+        ...(failedApps.length > 0 ? { failedApps } : {}),
       });
     },
   );

package/src/browser/CloudResourceSearch.browser-harness.tsx

@@ -0,0 +1,11 @@
+import { createGlobalSearchHost } from "../ssr/GlobalSearchDialog";
+import { openCloudResourcePicker } from "./resource-picker";
+
+/**
+ * Opens the real global search, or with `?picker` the resource picker, for a browser test that answers
+ * `/api/search` with invented, line-by-line results. `?app=<id>` narrows either one to one app.
+ */
+const params = new URLSearchParams(location.search);
+const app = params.get("app") ?? undefined;
+if (params.has("picker")) void openCloudResourcePicker({ initialAppId: app });
+else createGlobalSearchHost(() => []).open(app ? { scope: { appId: app, label: params.get("label") ?? app } } : {});