@madewithremy/admin 0.1.6 → 0.1.7

package/dist/prod.js

@@ -3079,6 +3079,61 @@ function create2(ctx, params) {
     ...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(
@@ -3216,11 +3271,24 @@ var dataSourcesSpecs = {
     flags: {
       source: { type: "string" },
       // Where the corpus lives: a dedicated resource id from `infra list`, or
-      // `shared`. Only changeable while the source has nothing built.
+      // `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]",
     flags: {
@@ -3491,6 +3559,7 @@ 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) {
@@ -3499,13 +3568,14 @@ async function dataSourcesCreate(ctx, a) {
   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(
-    await create2(ctx, {
-      slug,
-      ...name ? { name } : {},
-      ...ingest ? { ingest } : {},
-      ...placement !== void 0 ? { placement } : {}
-    })
+    result.migration && !result.migration.error ? { ...result, note: MOVE_NOTE } : result
   );
 }
 async function dataSourcesConfig(ctx, a) {
@@ -3516,15 +3586,49 @@ async function dataSourcesConfig(ctx, a) {
     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 } : {},
-      ...placement !== void 0 ? { placement } : {}
-    })
+    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);
@@ -3600,6 +3704,7 @@ var dataSourcesHandlers = {
   "datasources search": dataSourcesSearch,
   "datasources create": dataSourcesCreate,
   "datasources config": dataSourcesConfig,
+  "datasources move": dataSourcesMove,
   "datasources revectorize": dataSourcesRevectorize,
   "datasources promote": dataSourcesPromote,
   "datasources drop": dataSourcesDrop,
@@ -3618,6 +3723,7 @@ Subcommands:
   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
@@ -3631,6 +3737,7 @@ Usage:
   remy-admin datasources search [--source <slug>] [search options] <query>
   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>]
@@ -3701,11 +3808,23 @@ Tuning a corpus:
                              capacity needs, roughly in proportion.
     --extraction-model <id>
 
-Notes:
+Placement (shared pool vs dedicated capacity, see \`infra --help\`):
   --source defaults to "${DEFAULT_SOURCE}" and is created on first use, on the
-    shared pool. A corpus meant for dedicated capacity (\`infra provision\`)
-    starts with \`create --placement <resource-id>\`, since a source with built
-    documents cannot move; \`config --placement\` moves one that is still empty.
+    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:
   --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
@@ -5527,6 +5646,14 @@ function destroy(ctx, params) {
     `${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,
@@ -5559,7 +5686,7 @@ async function waitForPhase(ctx, params) {
       await sleep(POLL_MS4);
       continue;
     }
-    if (wanted.has(resource.phase)) {
+    if (wanted.has(resource.phase) && (params.until?.(resource) ?? true)) {
       return { status: "done", resource };
     }
     if (resource.phase === "failed") {
@@ -5577,7 +5704,7 @@ async function waitForPhase(ctx, params) {
       };
     }
     params.onProgress?.(
-      `${resource.phase}${resource.detail ? ` \xB7 ${resource.detail}` : ""}\u2026 (${Math.round((Date.now() - start) / 1e3)}s)`
+      `${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);
   }
@@ -5626,13 +5753,27 @@ var infraSpecs = {
     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) {
+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
   });
@@ -5650,6 +5791,18 @@ async function infraList(ctx, a) {
 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");
@@ -5657,14 +5810,19 @@ async function infraProvision(ctx, a) {
     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" });
+  await waitAndReport(ctx, a, resource.id, ["active"], {
+    action: "provision",
+    pricing
+  });
 }
 async function infraHibernate(ctx, a) {
   const id = a.req("id");
@@ -5701,6 +5859,33 @@ async function infraRename(ctx, a) {
     })
   );
 }
+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,
@@ -5708,7 +5893,8 @@ var infraHandlers = {
   "infra hibernate": infraHibernate,
   "infra resume": infraResume,
   "infra destroy": infraDestroy,
-  "infra rename": infraRename
+  "infra rename": infraRename,
+  "infra resize": infraResize
 };
 var infraHelp = `remy-admin infra \u2014 Dedicated infrastructure your app leases from the platform.
 
@@ -5717,16 +5903,18 @@ 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 needs a month's worth of
-credits available in the workspace; nothing is charged until activation. Every
-action below is audited.
+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 (spends credits)
+  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
 
@@ -5736,26 +5924,44 @@ Usage:
   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 config --source <slug> --placement <resource-id>
-  remy-admin datasources config --source <slug> --placement shared
+  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. Placement can only change while the source has no built
-  documents; moving a populated source is a re-vectorization onto the new
-  capacity, which is not available yet. Searches on a source whose resource is
-  not active fail with capacity_<phase>: capacity_hibernated once parked,
-  capacity_hibernating / capacity_resuming while it moves, and
-  capacity_restoring while a resumed instance reloads its data.
-
-Phases:
+  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).
+  (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).`;
@@ -5916,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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@madewithremy/admin",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Admin SDK + CLI for managing production Remy apps",
   "type": "module",
   "main": "./dist/index.js",