@mycadet/assistant 0.12.9 → 0.12.11

package/src/cli/lib/bundled-plugin-packages.ts

@@ -1,87 +0,0 @@
-/**
- * Materialize reviewed local marketplace packages from the generated bundle.
- * Package keys come from plugins/marketplace.json and never resolve against a
- * caller-controlled filesystem root.
- */
-
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-import bundledPackages from "./bundled-plugin-packages.json" with { type: "json" };
-
-interface BundledPackageFile {
-  readonly path: string;
-  readonly contentBase64: string;
-}
-
-interface BundledPackage {
-  readonly version: string;
-  readonly files: readonly BundledPackageFile[];
-}
-
-const packages = bundledPackages.packages as Record<string, BundledPackage>;
-
-export class BundledPluginPackageError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "BundledPluginPackageError";
-  }
-}
-
-/** Return the embedded package when its path and version match the catalog. */
-export function getBundledPluginPackage(
-  path: string,
-  version: string,
-): BundledPackage | null {
-  const pluginPackage = packages[path];
-  return pluginPackage?.version === version ? pluginPackage : null;
-}
-
-/** Read one UTF-8 file from an exact embedded package. */
-export function readBundledPluginFile(
-  path: string,
-  version: string,
-  filePath: string,
-): string | null {
-  const file = getBundledPluginPackage(path, version)?.files.find(
-    (candidate) => candidate.path === filePath,
-  );
-  return file
-    ? Buffer.from(file.contentBase64, "base64").toString("utf8")
-    : null;
-}
-
-/** Copy one exact embedded package into an existing staging directory. */
-export function materializeBundledPluginPackage(
-  path: string,
-  version: string,
-  destination: string,
-): number {
-  const pluginPackage = getBundledPluginPackage(path, version);
-  if (!pluginPackage) {
-    throw new BundledPluginPackageError(
-      `Bundled plugin package ${path} @ ${version} is unavailable`,
-    );
-  }
-
-  for (const file of pluginPackage.files) {
-    if (
-      file.path.length === 0 ||
-      file.path.startsWith("/") ||
-      file.path.includes("\\") ||
-      file.path
-        .split("/")
-        .some(
-          (segment) => segment === "." || segment === ".." || segment === "",
-        )
-    ) {
-      throw new BundledPluginPackageError(
-        `Bundled plugin package ${path} contains an unsafe file path`,
-      );
-    }
-    const target = join(destination, ...file.path.split("/"));
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, Buffer.from(file.contentBase64, "base64"));
-  }
-  return pluginPackage.files.length;
-}

package/src/cli/lib/plugin-catalog-local.ts

@@ -1,94 +0,0 @@
-/**
- * Offline plugin catalog reader backed by the manifest bundled into the
- * package at build time. `bundled-marketplace.json` is a generated artifact
- * (git-ignored) that meta/sync-bundled-copies.ts copies from the canonical
- * plugins/marketplace.json before every build, test, and install — the same
- * treatment as the feature-flag registry.
- *
- * `getPluginCatalog` selects this reader only when platform features are
- * disabled (air-gapped / self-hosted, `CADET_DISABLE_CLOUD=true`). Importing
- * the JSON directly (resolveJsonModule) inlines it into the bundle, so there is
- * no filesystem path resolution and the manifest is always present at runtime —
- * it works identically in dev, Docker, and an npm-packed macOS install.
- */
-
-import bundledManifest from "./bundled-marketplace.json" with { type: "json" };
-import {
-  isPluginCatalogEntryVisible,
-  type PluginCatalogFeatureFlagResolver,
-} from "./plugin-catalog-visibility.js";
-import {
-  type MarketplaceEntry,
-  marketplaceManifestSchema,
-  type ResolvedPluginSource,
-  resolveMarketplaceSource,
-} from "./plugin-marketplace.js";
-import {
-  type PluginCatalog,
-  projectMarketplaceEntries,
-} from "./search-plugins.js";
-
-// Re-exported so `local`-tagged CLI commands can gate on platform features
-// without importing `platform/` directly (cli/no-daemon-internals allows lib).
-export { areCloudFeaturesEnabled } from "../../cloud/feature-gate.js";
-export { isPluginCatalogEntryVisible };
-
-let memoizedEntries: readonly MarketplaceEntry[] | undefined;
-
-/** Validated bundled manifest entries, parsed once and reused. */
-function bundledEntries(): readonly MarketplaceEntry[] {
-  memoizedEntries ??= marketplaceManifestSchema.parse(bundledManifest).plugins;
-  return memoizedEntries;
-}
-
-/**
- * Validate and project a marketplace manifest into a {@link PluginCatalog}:
- * every entry deduped by name, projected, and sorted alphabetically. A
- * malformed bundled manifest is a build defect, so parsing throws rather than
- * silently degrading. Defaults to the bundled manifest (parsed once); tests
- * pass an override to assert it throws on invalid input.
- */
-export function buildBundledPluginCatalog(
-  rawManifest: unknown = bundledManifest,
-): PluginCatalog {
-  const plugins =
-    rawManifest === bundledManifest
-      ? bundledEntries()
-      : marketplaceManifestSchema.parse(rawManifest).plugins;
-  return { ref: "bundled", matches: projectMarketplaceEntries(plugins) };
-}
-
-let memoized: PluginCatalog | undefined;
-
-/** Memoized {@link buildBundledPluginCatalog}, so the mapping runs once. */
-export function readBundledPluginCatalog(): PluginCatalog {
-  memoized ??= buildBundledPluginCatalog();
-  return memoized;
-}
-
-/** Local packages the current assistant release can materialize itself. */
-export function readBundledLocalPluginCatalog(): PluginCatalog {
-  return {
-    ref: "bundled",
-    matches: projectMarketplaceEntries(
-      bundledEntries().filter((entry) => entry.source.source === "local"),
-    ),
-  };
-}
-
-/**
- * Resolve an install name to its exact source from the bundled manifest, or
- * `null` when no bundled entry claims the name. The offline analogue of
- * resolving against the remote-fetched marketplace, used when platform
- * features are disabled and `assistant plugins install <name>` must resolve the
- * pin without any network call.
- */
-export function resolveBundledPluginSource(
-  name: string,
-  isFeatureFlagEnabled?: PluginCatalogFeatureFlagResolver,
-): ResolvedPluginSource | null {
-  if (!isPluginCatalogEntryVisible(name, isFeatureFlagEnabled)) {
-    return null;
-  }
-  return resolveMarketplaceSource(name, bundledEntries());
-}

package/src/cli/lib/plugin-pin-history.ts

@@ -1,276 +0,0 @@
-/**
- * Reconstruct the history of marketplace pins for a single plugin.
- *
- * The curated `plugins/marketplace.json` manifest (see {@link ./plugin-marketplace})
- * records only the *current* pin for each plugin — there is no stored version
- * list. But the manifest is a file in a Git repo, and every time a curator bumps
- * a plugin's pin, that is a commit to the manifest. So the history of reviewed
- * pins already exists as the commit history of that one file: this module walks
- * it (newest → oldest) via the GitHub API and reports the distinct pins a plugin
- * has been promoted to over time, each tagged with the marketplace commit an
- * install can reproduce it from.
- *
- * Why this is the safe source for "install an older version": every commit on
- * the default branch was reviewed and merged, so a pin drawn from this history
- * is a reviewed, known-good revision — unlike an arbitrary caller-supplied ref,
- * which the install route deliberately refuses. Resolving an older pin to the
- * marketplace commit that introduced it (rather than the plugin SHA directly)
- * also means the install reads that era's manifest, so the curated adapter stub
- * matches the pin and the historical version reproduces coherently.
- *
- * Designed for direct programmatic use with an injected `fetch`, mirroring the
- * sibling plugin libraries.
- */
-
-import type { FetchLike } from "./fetch-like.js";
-import { sanitizePluginName } from "./install-from-github.js";
-import { DEFAULT_PIN_HISTORY_LIMIT } from "./plugin-constants.js";
-import {
-  fetchMarketplaceEntries,
-  MARKETPLACE_MANIFEST_LOCATION,
-} from "./plugin-marketplace.js";
-import { USER_AGENT } from "./user-agent.js";
-
-/**
- * Cap on how many manifest-touching commits are inspected in one walk. Bounds
- * the GitHub API cost: a plugin whose pin changes rarely could otherwise force
- * a fetch of the manifest at every commit that touched it for *any* plugin.
- * Well above {@link DEFAULT_PIN_HISTORY_LIMIT} so the default listing is
- * complete in all but pathological histories.
- */
-const MAX_MARKETPLACE_COMMITS_SCANNED = 100;
-
-/** A single point in a plugin's marketplace-pin history. */
-export interface PluginPinHistoryEntry {
-  /** Plugin commit SHA pinned at this point in history. */
-  readonly pin: string;
-  /**
-   * Marketplace-manifest commit to install this pin from — the newest commit
-   * that carries it. Installing with this as the marketplace ref reproduces the
-   * pin together with the curated adapter stub of the same era.
-   */
-  readonly marketplaceCommit: string;
-  /**
-   * ISO-8601 committer date (UTC) of {@link PluginPinHistoryEntry.marketplaceCommit},
-   * i.e. when this pin was promoted; `null` when the date could not be read.
-   */
-  readonly promotedAt: string | null;
-  /** True for the pin currently active on the default branch. */
-  readonly current: boolean;
-}
-
-/** Options controlling the pin-history walk. */
-export interface ListPinHistoryOptions {
-  /** Max distinct pins to return (newest first). Defaults to {@link DEFAULT_PIN_HISTORY_LIMIT}. */
-  readonly limit?: number;
-  /** Marketplace branch to read history from. Defaults to `main`. */
-  readonly ref?: string;
-}
-
-/** Dependencies injected by the caller. */
-export interface ListPinHistoryDeps {
-  /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
-  readonly fetch: FetchLike;
-}
-
-/** Shape of a commit entry from the GitHub commits API. */
-interface GitHubCommitListEntry {
-  readonly sha: string;
-  readonly commit: {
-    readonly committer?: { readonly date?: string } | null;
-  } | null;
-}
-
-/** A manifest-touching commit and its committer date. */
-interface ManifestCommit {
-  readonly sha: string;
-  readonly date: string | null;
-}
-
-/** The pin-history walk could not read the marketplace commit list. */
-export class PluginPinHistoryError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "PluginPinHistoryError";
-  }
-}
-
-/**
- * List the commits that touched the marketplace manifest on `ref`, newest
- * first, capped at {@link MAX_MARKETPLACE_COMMITS_SCANNED}. A 404 (the file
- * never existed at this ref) yields an empty list.
- */
-async function listManifestCommits(
-  ref: string,
-  fetchFn: FetchLike,
-): Promise<ManifestCommit[]> {
-  const { owner, repo, path } = MARKETPLACE_MANIFEST_LOCATION;
-  const url =
-    `https://api.github.com/repos/${owner}/${repo}/commits` +
-    `?path=${encodeURIComponent(path)}` +
-    `&sha=${encodeURIComponent(ref)}` +
-    `&per_page=${MAX_MARKETPLACE_COMMITS_SCANNED}`;
-
-  const res = await fetchFn(url, {
-    headers: {
-      Accept: "application/vnd.github+json",
-      "User-Agent": USER_AGENT,
-    },
-  });
-  if (res.status === 404) {
-    return [];
-  }
-  if (!res.ok) {
-    throw new PluginPinHistoryError(
-      `Marketplace commit history fetch failed for ${path} @ ${ref}: HTTP ${res.status}`,
-    );
-  }
-
-  let body: unknown;
-  try {
-    body = JSON.parse(await res.text());
-  } catch (err) {
-    throw new PluginPinHistoryError(
-      `Marketplace commit history is not valid JSON: ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-    );
-  }
-  if (!Array.isArray(body)) {
-    throw new PluginPinHistoryError(
-      "Marketplace commit history response was not an array",
-    );
-  }
-
-  const commits: ManifestCommit[] = [];
-  for (const item of body as GitHubCommitListEntry[]) {
-    if (typeof item?.sha !== "string") {
-      continue;
-    }
-    const rawDate = item.commit?.committer?.date;
-    commits.push({
-      sha: item.sha,
-      date: typeof rawDate === "string" ? rawDate : null,
-    });
-  }
-  return commits;
-}
-
-/**
- * Resolve the plugin's pinned SHA in the manifest at a specific marketplace
- * commit, or `null` when no entry claims the name at that revision.
- */
-async function pinAtCommit(
-  name: string,
-  marketplaceCommit: string,
-  fetchFn: FetchLike,
-): Promise<string | null> {
-  const entries = await fetchMarketplaceEntries(
-    { fetch: fetchFn },
-    { ref: marketplaceCommit },
-  );
-  const source = entries.find((entry) => entry.name === name)?.source;
-  return source?.source === "github" ? source.ref : null;
-}
-
-/**
- * Walk a plugin's distinct marketplace pins, newest first. Each pin is yielded
- * once, tagged with the newest marketplace commit carrying it. Revisions where
- * the plugin is absent from the manifest are skipped (a gap, not a pin). The
- * `current` flag is set against the pin live on `ref` today.
- *
- * Bounded by {@link MAX_MARKETPLACE_COMMITS_SCANNED} commits scanned.
- */
-async function* iteratePinHistory(
-  name: string,
-  ref: string,
-  fetchFn: FetchLike,
-): AsyncGenerator<PluginPinHistoryEntry> {
-  const commits = await listManifestCommits(ref, fetchFn);
-  if (commits.length === 0) {
-    return;
-  }
-
-  // The pin live on the branch today, used to flag the current entry. Reading
-  // it explicitly (rather than assuming the newest commit carries it) stays
-  // correct even if the plugin was just removed from the manifest at the tip.
-  const currentPin = await pinAtCommit(name, ref, fetchFn);
-
-  let lastPin: string | null = null;
-  for (const commit of commits) {
-    const pin = await pinAtCommit(name, commit.sha, fetchFn);
-    if (pin === null) {
-      continue;
-    }
-    if (pin === lastPin) {
-      continue;
-    }
-    lastPin = pin;
-    yield {
-      pin,
-      marketplaceCommit: commit.sha,
-      promotedAt: commit.date,
-      current: currentPin !== null && pin === currentPin,
-    };
-  }
-}
-
-/**
- * List a plugin's distinct marketplace pins, newest first, capped at
- * `limit` (default {@link DEFAULT_PIN_HISTORY_LIMIT}). The first entry is the
- * current pin. An empty list means the plugin has no resolvable history at this
- * ref (never in the manifest, or the manifest does not exist).
- *
- * Throws {@link PluginPinHistoryError} when the commit list cannot be read, and
- * propagates a `MarketplaceFetchError` if a manifest revision fails to parse.
- */
-export async function listPinHistory(
-  name: string,
-  deps: ListPinHistoryDeps,
-  opts: ListPinHistoryOptions = {},
-): Promise<PluginPinHistoryEntry[]> {
-  const sanitized = sanitizePluginName(name);
-  const ref = opts.ref ?? "main";
-  const limit = opts.limit ?? DEFAULT_PIN_HISTORY_LIMIT;
-
-  const out: PluginPinHistoryEntry[] = [];
-  for await (const entry of iteratePinHistory(sanitized, ref, deps.fetch)) {
-    out.push(entry);
-    if (out.length >= limit) {
-      break;
-    }
-  }
-  return out;
-}
-
-/**
- * Resolve a plugin pin (a full commit SHA) to the marketplace commit it should
- * be installed from, by searching the plugin's pin history. Returns `null` when
- * the pin is not found in the scanned history — i.e. it is not a reviewed pin
- * this plugin was ever promoted to (or it predates the scan window).
- *
- * Case-insensitive on the SHA, matching the rest of the install pipeline. The
- * search walks the full scan window, not just the `limit` shown by
- * {@link listPinHistory}, so a pin older than the default listing still
- * resolves.
- */
-export async function resolvePinToMarketplaceCommit(
-  name: string,
-  pin: string,
-  deps: ListPinHistoryDeps,
-  opts: { readonly ref?: string } = {},
-): Promise<PluginPinHistoryEntry | null> {
-  const sanitized = sanitizePluginName(name);
-  const ref = opts.ref ?? "main";
-  const target = pin.trim().toLowerCase();
-  if (target.length === 0) {
-    return null;
-  }
-
-  for await (const entry of iteratePinHistory(sanitized, ref, deps.fetch)) {
-    if (entry.pin.toLowerCase() === target) {
-      return entry;
-    }
-  }
-  return null;
-}

package/src/cloud/feature-gate.ts

@@ -1,8 +0,0 @@
-import { getDisableCloud, getIsCloud } from "../config/env-registry.js";
-
-export function areCloudFeaturesEnabled(): boolean {
-  if (getIsCloud()) {
-    return true;
-  }
-  return !getDisableCloud();
-}

package/src/config/__tests__/cloud-rehydration.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { credentialKey } from "../../security/credential-key.js";
-
-let mockSecureKeys: Record<string, string> = {};
-let throwForKey: string | undefined;
-
-mock.module("../../security/secure-keys.js", () => ({
-  getSecureKeyAsync: async (key: string) => {
-    if (throwForKey && key === throwForKey) {
-      throw new Error("credential store unreachable");
-    }
-    return mockSecureKeys[key] ?? undefined;
-  },
-  // Peer tests in a combined run import this name from the same module; stub
-  // it so their ESM named-import validation is satisfied when this mock wins.
-  deleteSecureKeyAsync: async () => ({ deleted: false }),
-}));
-
-const {
-  getCloudAssistantId,
-  getCloudOrganizationId,
-  getCloudUserId,
-  setCloudAssistantId,
-  setCloudOrganizationId,
-  setCloudUserId,
-} = await import("../env.js");
-const { _resetCloudIdentityEnsureForTests } =
-  await import("../cloud-identity.js");
-const { rehydrateCloudCredentials } = await import("../cloud-rehydration.js");
-
-const PROD_URL = "https://cloud.mycadet.ai";
-const ASSISTANT_ID = "11111111-2222-4333-8444-555555555555";
-const ORG_ID = "22222222-3333-4444-8555-666666666666";
-const USER_ID = "33333333-4444-4555-8666-777777777777";
-
-describe("rehydrateCloudCredentials", () => {
-  const originalCloudUrlEnv = process.env.CADET_CLOUD_URL;
-  const originalOrgEnv = process.env.CLOUD_ORGANIZATION_ID;
-  const originalUserEnv = process.env.CLOUD_USER_ID;
-  const originalAssistantApiKeyEnv = process.env.ASSISTANT_API_KEY;
-  const originalFetch = globalThis.fetch;
-  const fetchCalls: Array<{ url: string; init?: RequestInit }> = [];
-  let fetchImpl: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response> = async () =>
-    new Response("not found", { status: 404 });
-
-  beforeEach(() => {
-    mockSecureKeys = {};
-    throwForKey = undefined;
-    fetchCalls.length = 0;
-    fetchImpl = async () => new Response("not found", { status: 404 });
-    globalThis.fetch = (async (
-      input: RequestInfo | URL,
-      init?: RequestInit,
-    ) => {
-      const url = typeof input === "string" ? input : input.toString();
-      fetchCalls.push({ url, init });
-      return fetchImpl(input, init);
-    }) as unknown as typeof fetch;
-    // Env vars take precedence over the rehydrated overrides for some fields;
-    // clear them so the credential-store values are what we observe.
-    delete process.env.CADET_CLOUD_URL;
-    delete process.env.CLOUD_ORGANIZATION_ID;
-    delete process.env.CLOUD_USER_ID;
-    delete process.env.ASSISTANT_API_KEY;
-    // Reset in-memory overrides between tests.
-    setCloudAssistantId(undefined);
-    setCloudOrganizationId(undefined);
-    setCloudUserId(undefined);
-    _resetCloudIdentityEnsureForTests();
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    if (originalCloudUrlEnv === undefined) {
-      delete process.env.CADET_CLOUD_URL;
-    } else {
-      process.env.CADET_CLOUD_URL = originalCloudUrlEnv;
-    }
-    if (originalOrgEnv === undefined) {
-      delete process.env.PLATFORM_ORGANIZATION_ID;
-    } else {
-      process.env.CLOUD_ORGANIZATION_ID = originalOrgEnv;
-    }
-    if (originalUserEnv === undefined) {
-      delete process.env.PLATFORM_USER_ID;
-    } else {
-      process.env.CLOUD_USER_ID = originalUserEnv;
-    }
-    if (originalAssistantApiKeyEnv === undefined) {
-      delete process.env.ASSISTANT_API_KEY;
-    } else {
-      process.env.ASSISTANT_API_KEY = originalAssistantApiKeyEnv;
-    }
-    setCloudAssistantId(undefined);
-    setCloudOrganizationId(undefined);
-    setCloudUserId(undefined);
-  });
-
-  test("leaves overrides untouched when nothing is stored", async () => {
-    await rehydrateCloudCredentials();
-
-    expect(getCloudAssistantId()).toBe("");
-    expect(getCloudOrganizationId()).toBe("");
-    expect(getCloudUserId()).toBe("");
-  });
-
-  test("a credential-store read failure does not throw", async () => {
-    throwForKey = credentialKey("cadet", "assistant_api_key");
-
-    await expect(rehydrateCloudCredentials()).resolves.toBeUndefined();
-    expect(getCloudAssistantId()).toBe("");
-  });
-
-  test("trades the assistant API key for ids via cloud validate", async () => {
-    process.env.CADET_CLOUD_URL = PROD_URL;
-    mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
-      "assistant-key";
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await rehydrateCloudCredentials();
-
-    expect(fetchCalls).toHaveLength(1);
-    expect(fetchCalls[0]?.url).toBe(
-      `${PROD_URL}/v1/internal/assistants/validate/`,
-    );
-    const headers = new Headers(fetchCalls[0]?.init?.headers);
-    expect(headers.get("Authorization")).toBe("Api-Key assistant-key");
-    expect(getCloudAssistantId()).toBe(ASSISTANT_ID);
-    expect(getCloudOrganizationId()).toBe(ORG_ID);
-    expect(getCloudUserId()).toBe(USER_ID);
-  });
-
-  test("validate ids are used when the vault also has a copy", async () => {
-    mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
-      "assistant-key";
-    mockSecureKeys[credentialKey("cadet", "platform_assistant_id")] =
-      "asst-from-vault";
-    fetchImpl = async () =>
-      new Response(
-        JSON.stringify({
-          assistant_id: ASSISTANT_ID,
-          organization_id: ORG_ID,
-          user_id: USER_ID,
-        }),
-        { status: 200 },
-      );
-
-    await rehydrateCloudCredentials();
-
-    expect(getCloudAssistantId()).toBe(ASSISTANT_ID);
-  });
-
-  test("does not populate ids from the vault when validate is unreachable", async () => {
-    mockSecureKeys[credentialKey("cadet", "assistant_api_key")] =
-      "assistant-key";
-    mockSecureKeys[credentialKey("cadet", "platform_assistant_id")] =
-      ASSISTANT_ID;
-    fetchImpl = async () => {
-      throw new Error("network down");
-    };
-
-    await rehydrateCloudCredentials();
-
-    expect(getCloudAssistantId()).toBe("");
-    expect(getCloudOrganizationId()).toBe("");
-    expect(getCloudUserId()).toBe("");
-  });
-});

package/src/config/cloud-rehydration.ts

@@ -1,35 +0,0 @@
-/**
- * Rehydrate the in-memory cloud identity overrides at process startup.
- *
- * The identity overrides (the ID setters in `config/env.ts`) are normally
- * only populated at runtime when the cloud pushes values. Any standalone
- * process that talks to the cloud — the daemon and the schedule worker —
- * must rehydrate them before its first request.
- *
- * Bound ids come from `POST /v1/internal/assistants/validate/`, which trades
- * the assistant API key for assistant/organization/user ids. The base URL is
- * intentionally NOT rehydrated here: it resolves from `config.cloud.baseUrl`
- * or the `CADET_CLOUD_URL` environment variable, never the credential
- * store.
- *
- * Safe to call more than once.
- */
-import { getLogger } from "../util/logger.js";
-import { ensureCloudIdentityIds } from "./cloud-identity.js";
-
-const log = getLogger("cloud-rehydration");
-
-/**
- * Rehydrate the cloud identity ids (assistant, organization, user). Safe to
- * call more than once.
- */
-export async function rehydrateCloudCredentials(): Promise<void> {
-  try {
-    await ensureCloudIdentityIds();
-  } catch (err) {
-    log.warn(
-      { error: err instanceof Error ? err.message : String(err) },
-      "Failed to rehydrate cloud identity ids (non-fatal)",
-    );
-  }
-}