@k2b/cloud 0.23.0 → 0.25.0

package/src/browser/choose-files.tsx

@@ -0,0 +1,70 @@
+import { showFileDialog } from "@k2b/stdlib/browser";
+import { dialogCore, panelDialogWorkspaceOptions } from "@k2b/ui";
+import { createSignal } from "solid-js";
+import { type ChooseFilesOptions, FileChooser, type FileProviderList } from "./FileChooser";
+import type { FileProviderCaller, FileProviderSource } from "./file-providers";
+
+/**
+ * One page's file choosing: the provider list is loaded once and kept; a failed load is tried again on the next
+ * request. `caller` carries the locale and, in tests, the transport.
+ */
+export const createFileChoosing = (
+  loadProviders: () => Promise<FileProviderSource[]>,
+  caller: () => FileProviderCaller = () => ({ locale: document.documentElement.lang || "en" }),
+) => {
+  let request: Promise<readonly FileProviderSource[]> | undefined;
+  let known: readonly FileProviderSource[] | undefined;
+  const providers = (): Promise<readonly FileProviderSource[]> => {
+    request ??= loadProviders().then(
+      (list) => {
+        known = list;
+        return list;
+      },
+      (error: unknown) => {
+        request = undefined;
+        throw error;
+      },
+    );
+    return request;
+  };
+
+  const chooseFiles = (options: ChooseFilesOptions = {}): Promise<File[]> => {
+    const { signal } = options;
+    if (signal?.aborted) return Promise.resolve([]);
+    if (known?.length === 0) {
+      // Synchronous on purpose: the native dialog needs the caller's user activation.
+      const picked = options.multiple
+        ? showFileDialog({ accept: options.accept, multiple: true })
+        : showFileDialog({ accept: options.accept }).then((file) => [file]);
+      // The page cannot close a native dialog; an abort resolves `[]` at once and a later pick is dropped.
+      return new Promise((resolve) => {
+        const abort = () => resolve([]);
+        signal?.addEventListener("abort", abort, { once: true });
+        picked.then(resolve, () => resolve([])).finally(() => signal?.removeEventListener("abort", abort));
+      });
+    }
+    const [list, setList] = createSignal<FileProviderList>(known ? { state: "ready", providers: known } : { state: "loading" });
+    const load = () => {
+      setList({ state: "loading" });
+      providers().then(
+        (value) => setList({ state: "ready", providers: value }),
+        () => setList({ state: "error" }),
+      );
+    };
+    if (!known) load();
+    return dialogCore
+      .open<File[]>((close) => <FileChooser options={options} providers={list} retryProviders={load} caller={caller} close={close} />, {
+        ...panelDialogWorkspaceOptions,
+        panelClassName: `${panelDialogWorkspaceOptions.panelClassName} cloud-file-chooser-dialog`,
+        initialFocus: (dialog) => dialog.querySelector<HTMLElement>('[role="gridcell"][tabindex="0"]'),
+        signal: options.signal,
+        history: true,
+      })
+      .then((files) => files ?? []);
+  };
+
+  return {
+    chooseFiles,
+    prefetch: () => void providers().catch(() => undefined),
+  };
+};

package/src/browser/file-chooser-messages.ts

@@ -0,0 +1,86 @@
+import { i18n } from "@k2b/stdlib";
+
+export const fileChooserMessages = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      title: ({ multiple }: { multiple: boolean }): string => (multiple ? "Add files" : "Add a file"),
+      sources: "Sources",
+      sourceList: "Where the files come from",
+      device: "This device",
+      providersLoading: "Looking for apps with files…",
+      providersFailed: "Apps with files could not be loaded.",
+      retry: "Try again",
+      up: "Up",
+      breadcrumbs: "Folder path",
+      filter: "Filter by name",
+      entries: ({ folder }: { folder: string }) => `Contents of ${folder}`,
+      loading: "Loading…",
+      loadMore: "Load more",
+      emptyFolder: "This folder is empty",
+      noMatches: ({ query }: { query: string }) => `Nothing matches “${query}”`,
+      clearFilter: "Clear filter",
+      offline: "You are offline",
+      offlineHint: "Check your connection, then try again.",
+      unavailable: ({ app }: { app: string }) => `${app} is not available right now`,
+      unavailableHint: "Try again in a moment.",
+      noAccess: "You no longer have access to this folder",
+      notFound: "This folder no longer exists",
+      backHint: "Go back and choose another folder.",
+      loadFailed: "This folder could not be loaded",
+      folderAnnounced: ({ folder, count, more }: { folder: string; count: number; more: boolean }) =>
+        `${folder}, ${i18n.plural(count, "en", { one: `${count} entry`, other: `${count} entries` })}${more ? ", more available" : ""}`,
+      tooLarge: ({ limit }: { limit: string }) => `Too large, up to ${limit}`,
+      tooLargeTogether: ({ limit }: { limit: string }) => `Too large together, up to ${limit}`,
+      wrongType: "Not supported here",
+      selected: ({ count }: { count: number }) => i18n.plural(count, "en", { one: "1 file selected", other: `${count} files selected` }),
+      selectHint: ({ multiple }: { multiple: boolean }): string => (multiple ? "Select one or more files" : "Select a file"),
+      cancel: "Cancel",
+      add: "Add",
+      downloading: ({ done, total, failed }: { done: number; total: number; failed: number }) =>
+        `${done} of ${total} ready${failed > 0 ? `, ${failed} failed` : ""}`,
+      downloadProgress: ({ name }: { name: string }) => `Downloading ${name}`,
+      waiting: "Waiting",
+      readFailed: "Could not be downloaded",
+    },
+    de: {
+      title: ({ multiple }) => (multiple ? "Dateien hinzufügen" : "Datei hinzufügen"),
+      sources: "Quellen",
+      sourceList: "Woher die Dateien kommen",
+      device: "Dieses Gerät",
+      providersLoading: "Apps mit Dateien werden gesucht…",
+      providersFailed: "Apps mit Dateien konnten nicht geladen werden.",
+      retry: "Erneut versuchen",
+      up: "Nach oben",
+      breadcrumbs: "Ordnerpfad",
+      filter: "Nach Namen filtern",
+      entries: ({ folder }) => `Inhalt von ${folder}`,
+      loading: "Wird geladen…",
+      loadMore: "Mehr laden",
+      emptyFolder: "Dieser Ordner ist leer",
+      noMatches: ({ query }) => `Nichts passt zu „${query}“`,
+      clearFilter: "Filter löschen",
+      offline: "Du bist offline",
+      offlineHint: "Prüfe deine Verbindung und versuche es erneut.",
+      unavailable: ({ app }) => `${app} ist gerade nicht erreichbar`,
+      unavailableHint: "Versuche es gleich noch einmal.",
+      noAccess: "Du hast keinen Zugriff mehr auf diesen Ordner",
+      notFound: "Diesen Ordner gibt es nicht mehr",
+      backHint: "Geh zurück und wähle einen anderen Ordner.",
+      loadFailed: "Dieser Ordner konnte nicht geladen werden",
+      folderAnnounced: ({ folder, count, more }) =>
+        `${folder}, ${i18n.plural(count, "de", { one: `${count} Eintrag`, other: `${count} Einträge` })}${more ? ", weitere verfügbar" : ""}`,
+      tooLarge: ({ limit }) => `Zu groß, höchstens ${limit}`,
+      tooLargeTogether: ({ limit }) => `Zusammen zu groß, höchstens ${limit}`,
+      wrongType: "Hier nicht unterstützt",
+      selected: ({ count }) => i18n.plural(count, "de", { one: "1 Datei ausgewählt", other: `${count} Dateien ausgewählt` }),
+      selectHint: ({ multiple }) => (multiple ? "Wähle eine oder mehrere Dateien" : "Wähle eine Datei"),
+      cancel: "Abbrechen",
+      add: "Hinzufügen",
+      downloading: ({ done, total, failed }) => `${done} von ${total} bereit${failed > 0 ? `, ${failed} fehlgeschlagen` : ""}`,
+      downloadProgress: ({ name }) => `${name} wird heruntergeladen`,
+      waiting: "Wartet",
+      readFailed: "Konnte nicht heruntergeladen werden",
+    },
+  },
+});

package/src/browser/file-providers.ts

@@ -0,0 +1,217 @@
+import { checkMimeType } from "@k2b/stdlib/browser";
+import { invokeCapabilityWithDataSchema, listCapabilityCatalog } from "../capabilities/client";
+import { transferCapabilityStream } from "../capabilities/streams";
+import type { CapabilityCatalogApp, CapabilityClientError, CapabilityHttpOptions } from "../capabilities/types";
+import { CapabilityErrorSchema } from "../contracts/capabilities";
+import {
+  type FileProviderEntry,
+  FileProviderListDataSchema,
+  FileProviderReadDataSchema,
+  fileProviderIssues,
+} from "../contracts/file-provider";
+import { LOCALE_HEADER } from "../shared/locale";
+
+/** One live application whose catalog manifest offers files, reduced to what choosing a file needs. */
+export type FileProviderSource = {
+  appId: string;
+  name: string;
+  icon: string;
+  list: string;
+  read: string;
+  /** The provider's read limit; a consumer combines it with its own. */
+  maxBytes: number;
+};
+
+export type FileProviderCaller = Pick<CapabilityHttpOptions, "fetch" | "baseUrl"> & { locale: string };
+
+/** A provider failure the chooser explains; `status` 0 means the browser is offline. */
+export class FileProviderError extends Error {
+  constructor(
+    readonly code: string,
+    message: string,
+    readonly status: number,
+  ) {
+    super(message);
+    this.name = "FileProviderError";
+  }
+}
+
+/** The page size the chooser asks for; the contract allows 1 to 100. */
+export const FILE_PROVIDER_PAGE_SIZE = 50;
+/** At most this many provider reads run at the same time. */
+export const FILE_PROVIDER_PARALLEL_READS = 2;
+
+const ICON = /^ti(?: ti-[a-z0-9-]{1,60}){1,2}$/;
+/** Icons come from other applications; only a Tabler icon class may reach the DOM, never arbitrary classes. */
+export const providerIcon = (icon: string | undefined, fallback: string): string => (icon && ICON.test(icon) ? icon : fallback);
+
+const options = (caller: FileProviderCaller): CapabilityHttpOptions => ({
+  fetch: caller.fetch,
+  baseUrl: caller.baseUrl,
+  headers: { [LOCALE_HEADER]: caller.locale },
+});
+
+const failure = (error: CapabilityClientError): FileProviderError =>
+  new FileProviderError(error.code, error.message, typeof navigator !== "undefined" && navigator.onLine === false ? 0 : error.status);
+
+/** One unreadable manifest leaves out that application, not the whole list. */
+const usable = (app: CapabilityCatalogApp): boolean => {
+  try {
+    return !fileProviderIssues(app.manifest).some((issue) => issue.function !== "save");
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Keeps the catalog apps that offer files with a usable `list` and `read`. Core already drops invalid declarations;
+ * the check repeats here because a manifest from another Cloud release may name an operation this reader left out.
+ */
+export const fileProviderSources = (apps: readonly CapabilityCatalogApp[], locale: string): FileProviderSource[] =>
+  apps
+    .flatMap((app) => {
+      const declaration = app.manifest.fileProvider;
+      if (!declaration || !usable(app)) return [];
+      const read = app.manifest.queries.find((query) => query.localId === declaration.read);
+      if (!read?.stream) return [];
+      return [
+        {
+          appId: app.appId,
+          name: app.appName,
+          icon: providerIcon(app.appIcon, "ti ti-folders"),
+          list: declaration.list,
+          read: declaration.read,
+          maxBytes: read.stream.maxBytes,
+        },
+      ];
+    })
+    .sort((a, b) => a.name.localeCompare(b.name, locale));
+
+/** Reads every catalog page; the catalog is the only discovery, there is no provider route. */
+export const loadFileProviders = async (caller: FileProviderCaller, signal?: AbortSignal): Promise<FileProviderSource[]> => {
+  const apps: CapabilityCatalogApp[] = [];
+  let cursor: string | undefined;
+  do {
+    const result = await listCapabilityCatalog({ ...options(caller), limit: 25, cursor, signal });
+    if (!result.ok) throw failure(result.error);
+    apps.push(...result.data.apps);
+    const next = result.data.page.hasMore ? result.data.page.nextCursor : undefined;
+    if (next && cursor && next <= cursor) throw new FileProviderError("INVALID_APP_RESPONSE", "Invalid catalog cursor", 502);
+    cursor = next;
+  } while (cursor);
+  return fileProviderSources(apps, caller.locale);
+};
+
+export type FileProviderPage = { items: FileProviderEntry[]; next: string | null };
+
+/** One folder page. Without `parent` it is the provider's root. */
+export const listProviderFolder = async (
+  provider: FileProviderSource,
+  input: { parent?: string; query?: string; cursor?: string },
+  caller: FileProviderCaller,
+  signal?: AbortSignal,
+): Promise<FileProviderPage> => {
+  const result = await invokeCapabilityWithDataSchema(
+    {
+      appId: provider.appId,
+      capabilityId: provider.list,
+      kind: "query",
+      input: {
+        ...(input.parent === undefined ? {} : { parent: input.parent }),
+        ...(input.query ? { query: input.query } : {}),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+        limit: FILE_PROVIDER_PAGE_SIZE,
+      },
+      signal,
+    },
+    FileProviderListDataSchema,
+    options(caller),
+  );
+  if (!result.ok) throw failure(result.error);
+  return { items: result.data.data.items, next: result.data.data.next };
+};
+
+export type EntryProblem = "type" | "size";
+
+/** Why a file cannot be chosen: its type does not match `accept`, or it is larger than the effective limit. */
+export const entryProblem = (entry: FileProviderEntry, accept: string | undefined, maxBytes: number): EntryProblem | undefined => {
+  if (entry.kind === "folder") return undefined;
+  if (accept && !checkMimeType(new File([], entry.name, { type: entry.mediaType ?? "" }), accept)) return "type";
+  if (entry.size > maxBytes) return "size";
+  return undefined;
+};
+
+const streamFailure = async (response: Response): Promise<FileProviderError> => {
+  const body = CapabilityErrorSchema.safeParse(await response.json().catch(() => null));
+  return body.success
+    ? new FileProviderError(body.data.code, body.data.message, response.status)
+    : new FileProviderError("INVALID_APP_RESPONSE", `Read failed with status ${response.status}`, response.status);
+};
+
+/**
+ * Reads one file through the provider's read stream into a `File`. Before any byte moves it checks the read's own
+ * size and media type against `maxBytes` and `accept` again, since the file may have changed since it was listed.
+ * It rejects a body that differs from the announced size and reports received bytes. Aborting the signal cancels
+ * the transfer.
+ */
+export const readProviderFile = async (
+  provider: FileProviderSource,
+  entry: Extract<FileProviderEntry, { kind: "file" }>,
+  caller: FileProviderCaller & {
+    maxBytes: number;
+    accept?: string;
+    signal?: AbortSignal;
+    onProgress?: (loaded: number, total: number) => void;
+  },
+): Promise<File> => {
+  const result = await invokeCapabilityWithDataSchema(
+    { appId: provider.appId, capabilityId: provider.read, kind: "query", input: { id: entry.id }, signal: caller.signal },
+    FileProviderReadDataSchema,
+    options(caller),
+  );
+  if (!result.ok) throw failure(result.error);
+  const stream = result.data.stream;
+  if (stream?.direction !== "read") throw new FileProviderError("INVALID_APP_RESPONSE", "The provider returned no read stream", 502);
+  const problem = entryProblem({ ...entry, size: stream.size, mediaType: stream.mediaType }, caller.accept, caller.maxBytes);
+  if (problem === "size") throw new FileProviderError("FILE_TOO_LARGE", "The file is larger than allowed", 413);
+  if (problem === "type") throw new FileProviderError("UNSUPPORTED_MEDIA_TYPE", "The file type is not accepted", 415);
+  let response: Response;
+  try {
+    response = await transferCapabilityStream(stream, "read", { ...options(caller), signal: caller.signal });
+  } catch (error) {
+    if (caller.signal?.aborted) throw error;
+    throw new FileProviderError("APP_UNAVAILABLE", "The file could not be read", navigator.onLine === false ? 0 : 503);
+  }
+  if (!response.ok || !response.body) throw await streamFailure(response);
+  const reader = response.body.getReader();
+  const chunks: Uint8Array<ArrayBuffer>[] = [];
+  let loaded = 0;
+  caller.onProgress?.(0, stream.size);
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      caller.signal?.throwIfAborted();
+      if (done) break;
+      loaded += value.byteLength;
+      if (loaded > stream.size) throw new FileProviderError("INVALID_APP_RESPONSE", "The file is larger than announced", 502);
+      chunks.push(value);
+      caller.onProgress?.(loaded, stream.size);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => undefined);
+    if (error instanceof FileProviderError || caller.signal?.aborted) throw error;
+    throw new FileProviderError("APP_UNAVAILABLE", "The file could not be read", navigator.onLine === false ? 0 : 503);
+  }
+  if (loaded !== stream.size) throw new FileProviderError("INVALID_APP_RESPONSE", "The file ended early", 502);
+  const lastModified = entry.updatedAt ? Date.parse(entry.updatedAt) : Date.now();
+  return new File(chunks, entry.name, { type: stream.mediaType, lastModified });
+};
+
+/** Runs `work` for every item, at most `limit` at once. `work` handles its own failures. */
+export const eachLimited = async <T>(items: readonly T[], limit: number, work: (item: T) => Promise<void>): Promise<void> => {
+  let index = 0;
+  const run = async () => {
+    while (index < items.length) await work(items[index++]!);
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, run));
+};

package/src/browser/files.tsx

@@ -0,0 +1,23 @@
+import { createFileChoosing } from "./choose-files";
+import { loadFileProviders } from "./file-providers";
+
+export type { ChooseFilesOptions } from "./FileChooser";
+
+const pageLocale = () => (typeof document === "undefined" ? "en" : document.documentElement.lang || "en");
+const choosing = createFileChoosing(() => loadFileProviders({ locale: pageLocale() }));
+
+/**
+ * Lets the user choose files from this device or from any Cloud application that offers files.
+ *
+ * Call it from the click or key handler of your attach action. Without providers it opens the device's file
+ * dialog directly; otherwise it opens the source chooser, "This device" first. Files from a provider are read
+ * through its stream, at most two at a time, and never above `min(maxBytes, provider limit)`. Hand the result
+ * to your existing upload path: it resolves the chosen `File`s, or `[]` when the user cancels.
+ */
+export const chooseFiles = choosing.chooseFiles;
+
+// Discovery starts while the page is idle, so the first click already knows whether providers exist.
+if (typeof window !== "undefined") {
+  const idle = window.requestIdleCallback ?? ((callback: () => void) => window.setTimeout(callback, 1_000));
+  idle(() => choosing.prefetch());
+}

package/src/browser/resource-search-messages.ts

@@ -12,7 +12,15 @@ export const resourceSearchMessages = i18n.define({
       commandHint: "Choose an action, or type > next time.",
       searchFailed: "Search is currently unavailable. Try again.",
       navigationFailed: "Could not open this result. Try again.",
-      partialFailure: "Some search sources are unavailable. Results may be incomplete.",
+      stillSearching: ({ apps, count }: { apps: string; count: number }) =>
+        count === 1 ? `${apps} is still searching…` : `${apps} are still searching…`,
+      moreApps: ({ count }: { count: number }) => `${count} more`,
+      appTimedOut: ({ app }: { app: string }) => `${app} did not respond in time`,
+      appUnavailable: ({ app }: { app: string }) => `${app} is not available right now`,
+      appNoMatches: ({ app, query }: { app: string; query: string }) =>
+        query ? `${app}: no matches for “${query}”` : `${app}: no matches`,
+      searchDone: ({ count }: { count: number }) =>
+        i18n.plural(count, "en", { one: `Search complete, ${count} result`, other: `Search complete, ${count} results` }),
       searchPlaceholder: "Search Cloud…",
       scopedSearchPlaceholder: "Search…",
       searchCloudResources: "Search Cloud resources",
@@ -54,7 +62,12 @@ export const resourceSearchMessages = i18n.define({
       commandHint: "Wähle eine Aktion – beim nächsten Mal geht auch >.",
       searchFailed: "Suche gerade nicht erreichbar. Versuche es erneut.",
       navigationFailed: "Der Treffer konnte nicht geöffnet werden. Versuche es erneut.",
-      partialFailure: "Einige Suchquellen sind nicht erreichbar. Ergebnisse können unvollständig sein.",
+      stillSearching: ({ apps, count }) => (count === 1 ? `${apps} sucht noch …` : `${apps} suchen noch …`),
+      moreApps: ({ count }) => `${count} weitere`,
+      appTimedOut: ({ app }) => `${app} hat nicht rechtzeitig geantwortet`,
+      appUnavailable: ({ app }) => `${app} ist gerade nicht erreichbar`,
+      appNoMatches: ({ app, query }) => (query ? `${app}: keine Treffer für „${query}“` : `${app}: keine Treffer`),
+      searchDone: ({ count }) => `Suche abgeschlossen, ${count} Treffer`,
       searchPlaceholder: "Cloud durchsuchen…",
       scopedSearchPlaceholder: "Durchsuchen…",
       searchCloudResources: "Cloud-Inhalte durchsuchen",

package/src/browser/search-stream.ts

@@ -0,0 +1,151 @@
+import type { SearchApp, SearchItem, SearchProviderStatus, SearchResponse, SearchStreamLine } from "../api/search/schemas";
+import { LOCALE_HEADER } from "../shared/locale";
+
+/** Kept local so the browser bundle does not load the server-side search schemas. */
+const STREAM_CONTENT_TYPE = "application/x-ndjson";
+
+export type SearchAppStatus = SearchProviderStatus | "searching";
+
+/** Rows one provider line added. A retried app adds a block of its own at the end. */
+export type SearchBlock = { appId: string; items: SearchItem[] };
+
+/**
+ * One streamed search as the browser shows it. Blocks only ever grow at the end, so nothing already visible moves;
+ * `status` says for every app named in `start` whether it is still searching and how it finished.
+ */
+export type SearchRun = {
+  apps: SearchApp[];
+  providers: string[];
+  status: Record<string, SearchAppStatus>;
+  blocks: SearchBlock[];
+  unsupportedTags: string[];
+  /** The stream has ended; a retried app may still search afterwards. */
+  done: boolean;
+  /** The request failed before any app was named. */
+  failed: boolean;
+};
+
+export const emptySearchRun = (): SearchRun => ({
+  apps: [],
+  providers: [],
+  status: {},
+  blocks: [],
+  unsupportedTags: [],
+  done: false,
+  failed: false,
+});
+
+const itemKey = (item: SearchItem) => `${item.ref.type}\u0000${item.ref.id}`;
+
+export const applySearchLine = (run: SearchRun, line: SearchStreamLine): SearchRun => {
+  if (line.type === "start")
+    return {
+      ...run,
+      apps: line.apps,
+      providers: line.providers,
+      status: Object.fromEntries(line.providers.map((appId) => [appId, "searching" as const])),
+      unsupportedTags: line.unsupportedTags ?? [],
+    };
+  if (line.type === "done") return { ...run, done: true };
+  // Only an app that is searching takes a line, which bounds the lines a run accepts.
+  if (run.status[line.provider] !== "searching") return run;
+  const shown = new Set(run.blocks.flatMap((block) => block.items.map(itemKey)));
+  const items = line.results.filter((item) => !shown.has(itemKey(item)));
+  return {
+    ...run,
+    status: { ...run.status, [line.provider]: line.status },
+    blocks: items.length ? [...run.blocks, { appId: line.provider, items }] : run.blocks,
+  };
+};
+
+/**
+ * The request failed or the stream broke off. Once apps were named, the rows that arrived stay and every app still
+ * searching has failed on its own, with its own retry; before that, the search failed as a whole.
+ */
+export const breakSearchRun = (run: SearchRun): SearchRun =>
+  run.providers.length
+    ? {
+        ...run,
+        done: true,
+        status: Object.fromEntries(Object.entries(run.status).map(([appId, status]) => [appId, status === "searching" ? "error" : status])),
+      }
+    : { ...run, failed: true };
+
+/** Marks an app as searching again before its retry starts. */
+export const retrySearchApp = (run: SearchRun, appId: string): SearchRun => ({
+  ...run,
+  status: { ...run.status, [appId]: "searching" },
+});
+
+export const searchingApps = (run: SearchRun) => run.providers.filter((appId) => run.status[appId] === "searching");
+export const failedSearchApps = (run: SearchRun) =>
+  run.providers.flatMap((appId) => {
+    const status = run.status[appId];
+    return status === "timeout" || status === "error" ? [{ appId, status }] : [];
+  });
+/** Every app has answered: only now may an empty run say that nothing was found. */
+export const searchFinished = (run: SearchRun) => (run.done || run.failed) && searchingApps(run).length === 0;
+
+/** An older Core answers with merged JSON; it becomes the same lines, without per-app timing. */
+const linesFromResponse = (body: SearchResponse): SearchStreamLine[] => {
+  const failed = body.failedApps ?? [];
+  const found = [...new Set(body.items.map((item) => item.appId))];
+  return [
+    {
+      type: "start",
+      query: body.query,
+      apps: body.apps,
+      providers: [...new Set([...found, ...failed])],
+      ...(body.unsupportedTags ? { unsupportedTags: body.unsupportedTags } : {}),
+    },
+    ...found.map((appId): SearchStreamLine => {
+      const results = body.items.filter((item) => item.appId === appId);
+      return { type: "provider", provider: appId, status: failed.includes(appId) ? "error" : "ok", results, ms: 0 };
+    }),
+    ...failed
+      .filter((appId) => !found.includes(appId))
+      .map((appId): SearchStreamLine => ({ type: "provider", provider: appId, status: "error", results: [], ms: 0 })),
+    { type: "done", status: failed.length ? "partial" : "complete", count: body.items.length },
+  ];
+};
+
+/**
+ * Runs one search against `/api/search` and hands over each line as it arrives. Aborting `signal` ends the request,
+ * and with it every provider the server still waits for. Rejects when the request fails or the stream breaks off.
+ */
+export const streamCloudResourceSearch = async (
+  url: string,
+  options: { signal: AbortSignal; locale: string; onLine: (line: SearchStreamLine) => void },
+): Promise<void> => {
+  const response = await fetch(url, {
+    signal: options.signal,
+    headers: { accept: STREAM_CONTENT_TYPE, [LOCALE_HEADER]: options.locale },
+  });
+  if (!response.ok) throw new Error(`Search failed with ${response.status}`);
+  if (!response.headers.get("content-type")?.startsWith(STREAM_CONTENT_TYPE)) {
+    const body: SearchResponse = await response.json();
+    for (const line of linesFromResponse(body)) options.onLine(line);
+    return;
+  }
+  if (!response.body) throw new Error("Search returned no body");
+  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+  let buffer = "";
+  let closed = false;
+  while (!closed) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    buffer += chunk.value;
+    let end = buffer.indexOf("\n");
+    while (end >= 0) {
+      const text = buffer.slice(0, end).trim();
+      buffer = buffer.slice(end + 1);
+      if (text) {
+        const line: SearchStreamLine = JSON.parse(text);
+        options.onLine(line);
+        if (line.type === "done") closed = true;
+      }
+      end = buffer.indexOf("\n");
+    }
+  }
+  if (!closed) throw new Error("Search stream ended early");
+};

package/src/cli/admin/account-administration.ts

@@ -24,7 +24,7 @@ export const accountAdministrationCommands = [
         throw new Error(
           cliText(ctx, {
             en: "Account administration changes require --yes.",
-            de: "Änderungen an der Account-Verwaltung erfordern --yes.",
+            de: "Änderungen an der Account-Administration erfordern --yes.",
           }),
         );
       const input = await readCliInput(flags.config, { required: true, label: "Account administration configuration" });
@@ -39,7 +39,7 @@ export const accountAdministrationCommands = [
         }),
       );
       if (!printStructured(ctx, { saved: true }))
-        ctx.print(cliText(ctx, { en: "Account administration saved.", de: "Account-Verwaltung gespeichert." }));
+        ctx.print(cliText(ctx, { en: "Account administration saved.", de: "Account-Administration gespeichert." }));
     },
   }),
 ];