@madewithremy/admin 0.1.5 → 0.1.7

package/dist/prod.js

@@ -228,6 +228,16 @@ function parseCommand(spec, argv) {
 
 // src/http.ts
 var REQUEST_TIMEOUT_MS = 3e4;
+var TRANSIENT_GRACE_MS = 2 * 6e4;
+function isTransientError(err) {
+  if (err instanceof AdminApiError) {
+    return err.status >= 500;
+  }
+  if (err instanceof AdminTimeoutError) {
+    return true;
+  }
+  return err instanceof TypeError;
+}
 var REPORT_TIMEOUT_MS = 6e4;
 function seg(value) {
   return encodeURIComponent(String(value));
@@ -913,7 +923,9 @@ function summarizeRelease(release) {
   }
   return {
     ...summary2,
-    error: buildFailureReason(release) ?? "Build failed (no error entry in the build log)"
+    error: release.failureReason ?? buildFailureReason(release) ?? "Build failed (no error entry in the build log)",
+    ...release.failureKind ? { failureKind: release.failureKind } : {},
+    ...release.failurePhase ? { failurePhase: release.failurePhase } : {}
   };
 }
 var POLL_MS = 3e3;
@@ -1164,6 +1176,12 @@ the exit code so you can branch on $? without parsing:
 Any other failure (bad arguments, auth, API error) exits 10, so exit 1 always
 means the build itself failed.
 
+Every release shape ('get', 'list', 'status', 'wait') carries why a failed
+build failed: 'failureReason' (message), 'failurePhase' (the stage that was
+running), and 'failureKind' \u2014 'build' (the code), 'unbuildable' (commit is
+not a readable app), or 'interrupted' (a platform restart killed the build;
+a retry is already running, so don't re-push).
+
 Examples:
   git push origin HEAD && remy-admin releases wait
   remy-admin releases wait --commit 91ca67a --timeout 600
@@ -2919,12 +2937,26 @@ async function waitForIngest(ctx, params) {
   }
   const wanted = new Set(documentIds);
   const start = Date.now();
+  let transientSince = null;
   for (; ; ) {
-    const { documents: docs } = await call(
-      ctx,
-      "GET",
-      `${base(ctx.appId)}/documents?slug=${encodeURIComponent(slug)}`
-    );
+    let docs;
+    try {
+      docs = await allDocuments(ctx, { slug, ids: documentIds });
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      onProgress?.(
+        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      );
+      await sleep(POLL_MS2);
+      continue;
+    }
     const tracked = (docs ?? []).filter((d) => wanted.has(d.id));
     const pending = tracked.filter((d) => d.status === "processing");
     const failed = tracked.filter((d) => d.status === "error");
@@ -2949,12 +2981,41 @@ async function waitForIngest(ctx, params) {
     await sleep(POLL_MS2);
   }
 }
+var DOCUMENTS_IDS_MAX = 200;
 function documents(ctx, params) {
   return call(
     ctx,
     "GET",
-    `${base(ctx.appId)}/documents${qs({ slug: params.slug, candidate: params.candidate || void 0 })}`
-  );
+    `${base(ctx.appId)}/documents${qs({
+      slug: params.slug,
+      candidate: params.candidate || void 0,
+      ids: params.ids?.length ? params.ids.join(",") : void 0,
+      limit: params.limit,
+      cursor: params.cursor
+    })}`
+  );
+}
+async function allDocuments(ctx, params) {
+  const groups = params.ids ? Array.from(
+    { length: Math.ceil(params.ids.length / DOCUMENTS_IDS_MAX) },
+    (_, i) => params.ids.slice(i * DOCUMENTS_IDS_MAX, (i + 1) * DOCUMENTS_IDS_MAX)
+  ) : [void 0];
+  const out2 = [];
+  for (const ids of groups) {
+    let cursor;
+    do {
+      const page = await documents(ctx, {
+        slug: params.slug,
+        candidate: params.candidate,
+        ids,
+        limit: 1e3,
+        cursor
+      });
+      out2.push(...page.documents ?? []);
+      cursor = page.nextCursor ?? void 0;
+    } while (cursor);
+  }
+  return out2;
 }
 function list8(ctx) {
   return call(ctx, "GET", base(ctx.appId));
@@ -2996,7 +3057,7 @@ function configGet(ctx, slug) {
   );
 }
 function configSet(ctx, params) {
-  const { slug, ingest, retrieval } = params;
+  const { slug, ingest, retrieval, placement } = params;
   return call(
     ctx,
     "POST",
@@ -3004,10 +3065,75 @@ function configSet(ctx, params) {
     {
       slug,
       ...ingest ? { ingest } : {},
-      ...retrieval ? { retrieval } : {}
+      ...retrieval ? { retrieval } : {},
+      ...placement !== void 0 ? { placement } : {}
     }
   );
 }
+function create2(ctx, params) {
+  const { slug, name, ingest, placement } = params;
+  return call(ctx, "POST", base(ctx.appId), {
+    slug,
+    ...name ? { name } : {},
+    ...ingest ? { ingest } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
+}
+function move(ctx, params) {
+  return call(ctx, "POST", `${base(ctx.appId)}/move`, {
+    slug: params.slug,
+    placement: params.placement
+  });
+}
+async function waitForMove(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  const start = Date.now();
+  let transientSince = null;
+  for (; ; ) {
+    let source;
+    try {
+      const { dataSources } = await list8(ctx);
+      source = dataSources.find((s) => s.slug === params.slug);
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      params.onProgress?.(
+        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      );
+      await sleep(POLL_MS2);
+      continue;
+    }
+    if (!source) {
+      throw new Error(`Data source "${params.slug}" not found.`);
+    }
+    const migration = source.migration;
+    if (!migration) {
+      return { status: "done", source };
+    }
+    if (migration.error) {
+      return { status: "failed", source, error: migration.error };
+    }
+    if (Date.now() - start > timeoutMs) {
+      return {
+        status: "timeout",
+        source,
+        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s with ${migration.copied}/${migration.total} documents copied`
+      };
+    }
+    params.onProgress?.(
+      `moving\u2026 ${migration.copied}/${migration.total} documents (${Math.round(
+        (Date.now() - start) / 1e3
+      )}s)`
+    );
+    await sleep(POLL_MS2);
+  }
+}
 function revectorize(ctx, params) {
   const { slug, ingest } = params;
   return call(
@@ -3065,8 +3191,8 @@ function deleteSource(ctx, slug) {
 // src/commands/dataSources.ts
 var DEFAULT_SOURCE = "default";
 var POLL_MS3 = 3e3;
-var CONFIG_FLAGS = {
-  // Pinned — changing any of these needs a re-vectorize.
+var INGEST_FLAGS = {
+  chunking: { type: "string" },
   "max-chars": { type: "number", min: 200 },
   "min-chars": { type: "number", min: 0 },
   "drop-blocks": { type: "string" },
@@ -3074,9 +3200,12 @@ var CONFIG_FLAGS = {
   "contextual-model": { type: "string" },
   "describe-images": { type: "string" },
   "embedding-model": { type: "string" },
+  "embedding-dimensions": { type: "number", min: 1 },
   "image-model": { type: "string" },
-  "extraction-model": { type: "string" },
-  // Live — take effect on the next search, no rebuild.
+  "extraction-model": { type: "string" }
+};
+var CHUNKING_STRATEGIES = ["structural", "whole"];
+var RETRIEVAL_FLAGS = {
   rerank: { type: "string" },
   // Which cross-encoder reranks. Live, not pinned: a reranker runs at query
   // time over text already in the index, so switching costs nothing and is
@@ -3085,6 +3214,10 @@ var CONFIG_FLAGS = {
   hybrid: { type: "string" },
   "top-k": { type: "number", min: 1 }
 };
+var CONFIG_FLAGS = {
+  ...INGEST_FLAGS,
+  ...RETRIEVAL_FLAGS
+};
 var dataSourcesSpecs = {
   "datasources add": {
     usage: "Usage: remy-admin datasources add [--source <slug>] [--metadata <k=v,...>] [--wait] [--timeout <sec>] <file...>",
@@ -3124,9 +3257,37 @@ var dataSourcesSpecs = {
       highlight: { type: "boolean" }
     }
   },
+  "datasources create": {
+    usage: "Usage: remy-admin datasources create --source <slug> [--name <name>] [--placement <resource-id|shared>] [ingest settings...]",
+    flags: {
+      source: { type: "string" },
+      name: { type: "string" },
+      placement: { type: "string" },
+      ...INGEST_FLAGS
+    }
+  },
   "datasources config": {
-    usage: "Usage: remy-admin datasources config [--source <slug>] [settings...]",
-    flags: { source: { type: "string" }, ...CONFIG_FLAGS }
+    usage: "Usage: remy-admin datasources config [--source <slug>] [--placement <resource-id|shared>] [settings...]",
+    flags: {
+      source: { type: "string" },
+      // Where the corpus lives: a dedicated resource id from `infra list`, or
+      // `shared`. A populated source starts a background move (see `move`).
+      placement: { type: "string" },
+      ...CONFIG_FLAGS
+    }
+  },
+  "datasources move": {
+    usage: "Usage: remy-admin datasources move [--source <slug>] --to <resource-id|shared> [--wait] [--timeout <sec>]",
+    flags: {
+      source: { type: "string" },
+      to: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["to"],
+      message: "--to is required: a resource id from `infra list`, or `shared`."
+    }
   },
   "datasources revectorize": {
     usage: "Usage: remy-admin datasources revectorize [--source <slug>] [settings...] [--wait]",
@@ -3215,10 +3376,10 @@ async function dataSourcesList(ctx) {
 }
 async function dataSourcesStatus(ctx, a) {
   const slug = sourceOf(a);
-  const { documents: documents2 } = await documents(ctx, { slug });
+  const documents2 = await allDocuments(ctx, { slug });
   out({
     dataSource: slug,
-    documents: (documents2 ?? []).map(summarize)
+    documents: documents2.map(summarize)
   });
 }
 async function dataSourcesRm(ctx, a) {
@@ -3327,6 +3488,15 @@ function triState(a, flag, key) {
 }
 function configFromFlags(a) {
   const chunking = {};
+  const strategy = a.str("chunking");
+  if (strategy !== void 0) {
+    if (!CHUNKING_STRATEGIES.includes(strategy)) {
+      fatal(
+        `--chunking must be one of: ${CHUNKING_STRATEGIES.join(", ")} (got "${strategy}").`
+      );
+    }
+    chunking.strategy = strategy;
+  }
   if (a.num("max-chars") !== void 0) {
     chunking.maxChars = a.num("max-chars");
   }
@@ -3346,6 +3516,7 @@ function configFromFlags(a) {
     ...a.str("image-model") ? { modelId: a.str("image-model") } : {}
   };
   const embeddingModel = a.str("embedding-model");
+  const embeddingDimensions = a.num("embedding-dimensions");
   const extractionModel = a.str("extraction-model");
   const ingest = {};
   if (Object.keys(chunking).length) {
@@ -3357,8 +3528,11 @@ function configFromFlags(a) {
   if (Object.keys(images).length) {
     ingest.images = images;
   }
-  if (embeddingModel) {
-    ingest.embedding = { modelId: embeddingModel };
+  if (embeddingModel || embeddingDimensions !== void 0) {
+    ingest.embedding = {
+      ...embeddingModel ? { modelId: embeddingModel } : {},
+      ...embeddingDimensions !== void 0 ? { dimensions: embeddingDimensions } : {}
+    };
   }
   if (extractionModel) {
     ingest.extraction = { modelId: extractionModel };
@@ -3381,21 +3555,80 @@ function configFromFlags(a) {
     retrieval: Object.keys(retrieval).length ? retrieval : void 0
   };
 }
+var placementOf = (a) => {
+  const flag = a.str("placement");
+  return flag === void 0 ? void 0 : flag === "shared" ? "shared" : { resourceId: flag };
+};
+var MOVE_NOTE = "Moving in the background; `datasources list` shows progress, or re-run with `datasources move --wait`.";
+async function dataSourcesCreate(ctx, a) {
+  const slug = a.str("source");
+  if (!slug) {
+    fatal("--source is required.");
+  }
+  const { ingest } = configFromFlags(a);
+  const name = a.str("name");
+  const placement = placementOf(a);
+  const result = await create2(ctx, {
+    slug,
+    ...name ? { name } : {},
+    ...ingest ? { ingest } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
+  out(
+    result.migration && !result.migration.error ? { ...result, note: MOVE_NOTE } : result
+  );
+}
 async function dataSourcesConfig(ctx, a) {
   const slug = sourceOf(a);
   const { ingest, retrieval } = configFromFlags(a);
-  if (!ingest && !retrieval) {
+  const placement = placementOf(a);
+  if (!ingest && !retrieval && placement === void 0) {
     out(await configGet(ctx, slug));
     return;
   }
+  const result = await configSet(ctx, {
+    slug,
+    ...ingest ? { ingest } : {},
+    ...retrieval ? { retrieval } : {},
+    ...placement !== void 0 ? { placement } : {}
+  });
   out(
-    await configSet(ctx, {
-      slug,
-      ...ingest ? { ingest } : {},
-      ...retrieval ? { retrieval } : {}
-    })
+    result.placementChanged && result.migration && !result.migration.error ? { ...result, note: MOVE_NOTE } : result
   );
 }
+async function dataSourcesMove(ctx, a) {
+  const slug = sourceOf(a);
+  const to = a.str("to");
+  const placement = to === "shared" ? "shared" : { resourceId: to };
+  const started = await move(ctx, { slug, placement });
+  if (!started.migration || !a.bool("wait")) {
+    out({
+      dataSource: slug,
+      ...started,
+      ...started.migration ? { note: MOVE_NOTE } : {}
+    });
+    return;
+  }
+  const timeoutSec = a.num("timeout");
+  const result = await waitForMove(ctx, {
+    slug,
+    ...timeoutSec ? { timeoutMs: timeoutSec * 1e3 } : {},
+    onProgress: progress
+  });
+  out({
+    dataSource: slug,
+    status: result.status,
+    placement: result.source.placement,
+    migration: result.source.migration,
+    ..."error" in result ? { error: result.error } : {}
+  });
+  if (result.status === "failed") {
+    process.exit(EXIT.buildFailed);
+  }
+  if (result.status === "timeout") {
+    process.exit(EXIT.timeout);
+  }
+}
 async function dataSourcesRevectorize(ctx, a) {
   const slug = sourceOf(a);
   const { ingest } = configFromFlags(a);
@@ -3411,12 +3644,12 @@ async function dataSourcesRevectorize(ctx, a) {
   const timeoutMs = timeoutSec ? timeoutSec * 1e3 : DEFAULT_WAIT_TIMEOUT_MS;
   const start = Date.now();
   for (; ; ) {
-    const { documents: documents2 } = await documents(ctx, {
+    const documents2 = await allDocuments(ctx, {
       slug,
       candidate: true
     });
-    const pending = (documents2 ?? []).filter((d) => d.status === "processing");
-    const failed = (documents2 ?? []).filter((d) => d.status === "error");
+    const pending = documents2.filter((d) => d.status === "processing");
+    const failed = documents2.filter((d) => d.status === "error");
     if (pending.length === 0) {
       out({
         dataSource: slug,
@@ -3469,7 +3702,9 @@ var dataSourcesHandlers = {
   "datasources status": dataSourcesStatus,
   "datasources rm": dataSourcesRm,
   "datasources search": dataSourcesSearch,
+  "datasources create": dataSourcesCreate,
   "datasources config": dataSourcesConfig,
+  "datasources move": dataSourcesMove,
   "datasources revectorize": dataSourcesRevectorize,
   "datasources promote": dataSourcesPromote,
   "datasources drop": dataSourcesDrop,
@@ -3486,7 +3721,9 @@ Subcommands:
   status       Show per-document ingest state
   rm           Remove a document and its vectors
   search       Query a corpus \u2014 useful to sanity-check one you just built
+  create       Create an empty source, optionally on dedicated capacity
   config       Show or change how a corpus is processed and searched
+  move         Move a corpus between shared and dedicated capacity, data intact
   revectorize  Rebuild a corpus under new settings, alongside the live one
   promote      Make a rebuilt version live
   drop         Discard a candidate or a superseded version
@@ -3498,7 +3735,9 @@ Usage:
   remy-admin datasources status [--source <slug>]
   remy-admin datasources rm [--source <slug>] --document <id>
   remy-admin datasources search [--source <slug>] [search options] <query>
-  remy-admin datasources config [--source <slug>] [settings...]
+  remy-admin datasources create --source <slug> [--name <name>] [--placement <resource-id|shared>] [rebuild settings...]
+  remy-admin datasources config [--source <slug>] [--placement <resource-id|shared>] [settings...]
+  remy-admin datasources move [--source <slug>] --to <resource-id|shared> [--wait] [--timeout <sec>]
   remy-admin datasources revectorize [--source <slug>] [settings...] [--wait]
   remy-admin datasources promote [--source <slug>] [--force]
   remy-admin datasources drop [--source <slug>] [--version <n>]
@@ -3540,6 +3779,13 @@ Tuning a corpus:
   reprocessed. Changing these on a corpus that already has documents is
   REJECTED; use \`revectorize\` instead, which builds a new version alongside
   the live one so search never degrades:
+    --chunking <structural|whole>
+                             structural (default) splits on headings, blocks
+                             and paragraphs. whole embeds each document as one
+                             chunk: for corpora of short records (articles,
+                             tickets, product rows) where the document is the
+                             unit you want back. Documents over --max-chars
+                             (default 24000 for whole) fall back to structural.
     --max-chars <n>          Target chunk size (default 2000)
     --min-chars <n>          Merge chunks smaller than this (default 120)
     --drop-blocks <a,b>      Block types to discard, e.g. footer,header
@@ -3555,10 +3801,30 @@ Tuning a corpus:
                              invisible to search rather than merely ranked low.
     --image-model <id>
     --embedding-model <id>
+    --embedding-dimensions <n>  Vector width, for models that offer several
+                             (Matryoshka). Must be the model's native size or
+                             one it lists; the error names the choices.
+                             Smaller vectors cut index memory, and dedicated
+                             capacity needs, roughly in proportion.
     --extraction-model <id>
 
+Placement (shared pool vs dedicated capacity, see \`infra --help\`):
+  --source defaults to "${DEFAULT_SOURCE}" and is created on first use, on the
+    shared pool. Start a corpus on a resource with \`create --placement\`, or
+    move one at any time with \`move --to <resource-id|shared>\`.
+  A move copies the corpus's stored vectors onto the new capacity in the
+    background: no re-extraction, no re-embedding, no charge beyond the
+    resource itself. Search keeps working from the old placement until the
+    copy lands; add, rm, config, revectorize and delete are refused with
+    data_source_migrating until then. \`datasources list\` shows progress;
+    \`move --wait\` blocks on it (exits ${EXIT.buildFailed} if the move failed,
+    ${EXIT.timeout} on timeout). Moving to \`shared\` is how a source leaves a
+    resource you mean to destroy.
+  A move is refused while documents are still building or a candidate version
+    exists (data_source_busy), when the target is not active
+    (capacity_<phase>), or when it would not fit (capacity_exceeded).
+
 Notes:
-  --source defaults to "${DEFAULT_SOURCE}" and is created on first use.
   --wait blocks until processing finishes, so you can search immediately after.
     Exits ${EXIT.buildFailed} if a document failed, ${EXIT.timeout} on timeout.
   Re-adding an unchanged file is free: no upload, no re-embedding. Re-adding
@@ -5333,6 +5599,373 @@ Examples:
   remy-admin cron list --runs 50
   remy-admin cron run dailyDigest`;
 
+// src/ops/infra.ts
+var DEFAULT_WAIT_TIMEOUT_MS2 = 10 * 60 * 1e3;
+var POLL_MS4 = 3e3;
+function base2(appId) {
+  return `/_internal/v2/apps/${appId}/infra`;
+}
+function list11(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}${params?.includeDestroyed ? "?includeDestroyed=true" : ""}`
+  );
+}
+function get8(ctx, params) {
+  return call(
+    ctx,
+    "GET",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}`
+  );
+}
+function provision(ctx, params) {
+  return call(ctx, "POST", base2(ctx.appId), {
+    offeringId: params.offeringId,
+    ...params.name ? { name: params.name } : {}
+  });
+}
+function hibernate(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/hibernate`
+  );
+}
+function resume(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resume`
+  );
+}
+function destroy(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/destroy`
+  );
+}
+function resize(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/resize`,
+    { offeringId: params.offeringId }
+  );
+}
+function rename(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `${base2(ctx.appId)}/${encodeURIComponent(params.id)}/rename`,
+    { name: params.name }
+  );
+}
+async function waitForPhase(ctx, params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS2;
+  const wanted = new Set(params.phases);
+  const start = Date.now();
+  let transientSince = null;
+  for (; ; ) {
+    let resource;
+    try {
+      ({ resource } = await get8(ctx, { id: params.id }));
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      params.onProgress?.(
+        `retrying after a gateway error\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      );
+      await sleep(POLL_MS4);
+      continue;
+    }
+    if (wanted.has(resource.phase) && (params.until?.(resource) ?? true)) {
+      return { status: "done", resource };
+    }
+    if (resource.phase === "failed") {
+      return {
+        status: "failed",
+        resource,
+        error: resource.lastError ?? "The platform could not complete the change."
+      };
+    }
+    if (Date.now() - start > timeoutMs) {
+      return {
+        status: "timeout",
+        resource,
+        error: `Timed out after ${Math.round(timeoutMs / 1e3)}s; resource is still ${resource.phase}`
+      };
+    }
+    params.onProgress?.(
+      `${resource.phase}${resource.detail ? ` \xB7 ${resource.detail}` : ""}${resource.resizingTo ? ` \xB7 resizing to ${resource.resizingTo.label}` : ""}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+    );
+    await sleep(POLL_MS4);
+  }
+}
+
+// src/commands/infra.ts
+var infraSpecs = {
+  "infra list": {
+    usage: "Usage: remy-admin infra list [--include-destroyed]",
+    flags: { "include-destroyed": { type: "boolean" } }
+  },
+  "infra get": {
+    usage: "Usage: remy-admin infra get <id>",
+    positionals: [{ name: "id", required: true }]
+  },
+  "infra provision": {
+    usage: "Usage: remy-admin infra provision --offering <id> [--name <name>] [--wait] [--timeout <sec>]",
+    flags: {
+      offering: { type: "string" },
+      name: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["offering"],
+      message: "--offering is required (see `infra list` for the catalog)."
+    }
+  },
+  "infra hibernate": {
+    usage: "Usage: remy-admin infra hibernate <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "infra resume": {
+    usage: "Usage: remy-admin infra resume <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "infra destroy": {
+    usage: "Usage: remy-admin infra destroy <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { wait: { type: "boolean" }, timeout: { type: "string" } }
+  },
+  "infra rename": {
+    usage: "Usage: remy-admin infra rename <id> --name <name>",
+    positionals: [{ name: "id", required: true }],
+    flags: { name: { type: "string" } },
+    requireAnyOf: { flags: ["name"], message: "--name is required." }
+  },
+  "infra resize": {
+    usage: "Usage: remy-admin infra resize <id> --offering <id> [--wait] [--timeout <sec>]",
+    positionals: [{ name: "id", required: true }],
+    flags: {
+      offering: { type: "string" },
+      wait: { type: "boolean" },
+      timeout: { type: "string" }
+    },
+    requireAnyOf: {
+      flags: ["offering"],
+      message: "--offering is required (see `infra list` for the sizes)."
+    }
+  }
+};
+async function waitAndReport(ctx, a, id, phases, summary2, until) {
+  const timeoutSec = a.str("timeout");
+  const result = await waitForPhase(ctx, {
+    id,
+    phases,
+    ...until ? { until } : {},
+    ...timeoutSec ? { timeoutMs: Number(timeoutSec) * 1e3 } : {},
+    onProgress: progress
+  });
+  out({ ...summary2, ...result });
+  if (result.status === "failed") {
+    throw new CliError(result.error, EXIT.buildFailed);
+  }
+  if (result.status === "timeout") {
+    throw new CliError(result.error, EXIT.timeout);
+  }
+}
+async function infraList(ctx, a) {
+  out(await list11(ctx, { includeDestroyed: a.bool("include-destroyed") }));
+}
+async function infraGet(ctx, a) {
+  out(await get8(ctx, { id: a.req("id") }));
+}
+function pricingOf(resource) {
+  const offering = resource.offering;
+  if (!offering) {
+    return null;
+  }
+  return {
+    offering: offering.id,
+    activeMonthlyDollars: offering.monthlyPriceDollars,
+    hibernatedMonthlyDollars: offering.hibernatedMonthlyPriceDollars,
+    note: "Bills hourly from activation. A month's credits were verified before the lease was accepted."
+  };
+}
+async function infraProvision(ctx, a) {
+  const offeringId = a.str("offering");
+  const name = a.str("name");
+  const { resource } = await provision(ctx, {
+    offeringId,
+    ...name ? { name } : {}
+  });
+  const pricing = pricingOf(resource);
+  if (!a.bool("wait")) {
+    out({
+      resource,
+      pricing,
+      note: "Provisioning; poll `infra get <id>` or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(ctx, a, resource.id, ["active"], {
+    action: "provision",
+    pricing
+  });
+}
+async function infraHibernate(ctx, a) {
+  const id = a.req("id");
+  const { resource } = await hibernate(ctx, { id });
+  if (!a.bool("wait")) {
+    out({ resource });
+    return;
+  }
+  await waitAndReport(ctx, a, id, ["hibernated"], { action: "hibernate" });
+}
+async function infraResume(ctx, a) {
+  const id = a.req("id");
+  const { resource } = await resume(ctx, { id });
+  if (!a.bool("wait")) {
+    out({ resource });
+    return;
+  }
+  await waitAndReport(ctx, a, id, ["active"], { action: "resume" });
+}
+async function infraDestroy(ctx, a) {
+  const id = a.req("id");
+  const { resource } = await destroy(ctx, { id });
+  if (!a.bool("wait")) {
+    out({ resource });
+    return;
+  }
+  await waitAndReport(ctx, a, id, ["destroyed"], { action: "destroy" });
+}
+async function infraRename(ctx, a) {
+  out(
+    await rename(ctx, {
+      id: a.req("id"),
+      name: a.str("name")
+    })
+  );
+}
+async function infraResize(ctx, a) {
+  const id = a.req("id");
+  const { resource } = await resize(ctx, {
+    id,
+    offeringId: a.str("offering")
+  });
+  const pricing = pricingOf({
+    ...resource,
+    offering: resource.resizingTo ?? resource.offering
+  });
+  if (!a.bool("wait")) {
+    out({
+      resource,
+      pricing,
+      note: "Resizing; searches on its sources pause while it is parked and restored. Poll `infra get <id>` or re-run with --wait."
+    });
+    return;
+  }
+  await waitAndReport(
+    ctx,
+    a,
+    id,
+    [resource.phase],
+    { action: "resize", pricing },
+    (r) => r.resizingTo === null
+  );
+}
+var infraHandlers = {
+  "infra list": infraList,
+  "infra get": infraGet,
+  "infra provision": infraProvision,
+  "infra hibernate": infraHibernate,
+  "infra resume": infraResume,
+  "infra destroy": infraDestroy,
+  "infra rename": infraRename,
+  "infra resize": infraResize
+};
+var infraHelp = `remy-admin infra \u2014 Dedicated infrastructure your app leases from the platform.
+
+Today the one kind is dedicated retrieval: the app's own vector-store capacity
+for data sources, isolated from the shared pool. Sizes and prices come from the
+platform catalog (\`infra list\` prints them); nothing is priced client-side.
+
+A resource bills by the hour from activation, at the retained-storage rate while
+hibernated, and not at all once destroyed. Provisioning (and growing) needs a
+month's worth of credits available in the workspace, checked before the request
+is accepted; nothing is charged until activation. The provision output prints
+the price it committed to. Every action below is audited.
+
+Subcommands:
+  list        Resources on this app, plus the offerings you can provision
+  get         One resource with its state timeline and attached sources
+  provision   Lease a new resource (needs a month's credits; prints the price)
+  hibernate   Park it: data kept, searches paused, compute charge stops
+  resume      Bring a hibernated resource back
+  resize      Change its size, data intact (passes through hibernated)
+  destroy     Delete it (refused while data sources are placed on it)
+  rename      Change the display name
+
+Usage:
+  remy-admin infra list [--include-destroyed]
+  remy-admin infra get <id>
+  remy-admin infra provision --offering <id> [--name <name>] [--wait] [--timeout <sec>]
+  remy-admin infra hibernate <id> [--wait] [--timeout <sec>]
+  remy-admin infra resume <id> [--wait] [--timeout <sec>]
+  remy-admin infra resize <id> --offering <id> [--wait] [--timeout <sec>]
+  remy-admin infra destroy <id> [--wait] [--timeout <sec>]
+  remy-admin infra rename <id> --name <name>
+
+Placing a data source on a resource:
+  remy-admin datasources create --source <slug> --placement <resource-id>
+  remy-admin datasources move --source <slug> --to <resource-id|shared> [--wait]
+
+  Start a new corpus on a resource with \`create\`; \`add\` creates a source on
+  the shared pool. A populated source moves with \`datasources move\`: its
+  stored vectors are copied onto the new capacity in the background (no
+  re-embedding), search keeps working from the old placement until the copy
+  lands, and adding or removing documents is refused with
+  data_source_migrating until it finishes. Moving to \`shared\` is how a source
+  leaves a resource you mean to destroy. See \`datasources --help\`.
+
+  Searches on a source whose resource is not active fail with
+  capacity_<phase>: capacity_hibernated once parked, capacity_hibernating /
+  capacity_resuming while it moves. \`active\` means searchable: a resumed
+  resource reports active only once its data is restored. capacity_restoring
+  is the rare case of an active instance that was replaced (node loss) and is
+  refilling from its snapshot. The messages are written for the app's end
+  user; the stable code is what to act on.
+
+Resizing:
+  A resize keeps the data. The resource is parked (a fresh snapshot), its spec
+  is swapped, and it comes back up restored from that snapshot, so searches on
+  its sources pause for the few minutes it takes. A hibernated resource swaps
+  in place and stays parked. Growing needs a month's credits at the new rate;
+  shrinking is refused below what the resource holds (resize_too_small).
+  \`infra get\` shows resizingTo until the swap has happened.
+
+Phases and timing:
+  requested \u2192 provisioning \u2192 active \u21C4 hibernated \u2192 destroyed, with hibernating /
+  resuming / decommissioning in between and failed when a change cannot complete
+  (retried automatically; resume or hibernate to retry by hand). Each transition
+  takes about two minutes, more with more data: snapshots and restores scale
+  with the collection. --wait defaults to 600s; pass --timeout for a large one.
+
+--wait exit codes: 0 reached the target phase \xB7 1 the platform reported failure \xB7
+2 still transitioning when --timeout elapsed (default 600s).`;
+
 // src/commands/index.ts
 var SPECS = {
   ...requestsSpecs,
@@ -5356,7 +5989,8 @@ var SPECS = {
   ...jewelsSpecs,
   ...settingsSpecs,
   ...emailSpecs,
-  ...cronSpecs
+  ...cronSpecs,
+  ...infraSpecs
 };
 var HANDLERS = {
   ...requestsHandlers,
@@ -5380,7 +6014,8 @@ var HANDLERS = {
   ...jewelsHandlers,
   ...settingsHandlers,
   ...emailHandlers,
-  ...cronHandlers
+  ...cronHandlers,
+  ...infraHandlers
 };
 var GROUP_HELP = {
   requests: requestsHelp,
@@ -5404,7 +6039,8 @@ var GROUP_HELP = {
   jewels: jewelsHelp,
   settings: settingsHelp,
   email: emailHelp,
-  cron: cronHelp
+  cron: cronHelp,
+  infra: infraHelp
 };
 
 // src/ctx.ts
@@ -5486,6 +6122,7 @@ Commands:
   settings    App settings \u2014 signup allowlist, test accounts, embed origins, toggles
   email       Email \u2014 delivery log, blast stats, unsubscribes, inbox, custom domains
   cron        Scheduled jobs \u2014 schedules, run history, manual trigger
+  infra       Dedicated infrastructure \u2014 provision, hibernate, resize + destroy retrieval capacity
 
 Run 'remy-admin <command> --help' for details on each command.
 
@@ -5517,7 +6154,8 @@ var GROUPS = [
   "jewels",
   "settings",
   "email",
-  "cron"
+  "cron",
+  "infra"
 ];
 var KEYS = new Set(Object.keys(SPECS));
 function resolveRoute(argv) {