@madewithremy/admin 0.1.13 → 0.1.15

package/dist/prod.js

@@ -342,6 +342,62 @@ function statsForMethod(ctx, methodId, params = {}) {
   );
 }
 
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/poll.ts
+async function pollUntil(read, isSettled, options) {
+  const start2 = Date.now();
+  let movedAt = start2;
+  let lastKey;
+  let transientSince = null;
+  while (true) {
+    let value;
+    try {
+      value = await read();
+      transientSince = null;
+    } catch (err) {
+      if (!isTransientError(err)) {
+        throw err;
+      }
+      transientSince ??= Date.now();
+      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
+        throw err;
+      }
+      options.onProgress?.(
+        `retrying after a gateway error\u2026 (${elapsedSeconds(start2)}s)`
+      );
+      await sleep(options.pollMs);
+      continue;
+    }
+    if (isSettled(value)) {
+      return { settled: true, value };
+    }
+    if (options.progressKey) {
+      const key = options.progressKey(value);
+      if (key !== lastKey) {
+        lastKey = key;
+        movedAt = Date.now();
+      }
+    }
+    if (Date.now() - movedAt > options.timeoutMs) {
+      return { settled: false, value };
+    }
+    if (options.describe) {
+      options.onProgress?.(options.describe(value, start2));
+    }
+    await sleep(options.pollMs);
+  }
+}
+function elapsedSeconds(start2) {
+  return Math.round((Date.now() - start2) / 1e3);
+}
+function timedOut(timeoutMs, still) {
+  return `Timed out after ${Math.round(timeoutMs / 1e3)}s ${still}`;
+}
+
 // src/output.ts
 var PRETTY = process.stdout.isTTY === true;
 function out(data) {
@@ -352,6 +408,31 @@ function progress(message) {
   process.stderr.write(`${message}
 `);
 }
+function describeEta(eta, now = Date.now()) {
+  if (!eta) {
+    return null;
+  }
+  const minutes = Math.max(1, Math.round((Date.parse(eta) - now) / 6e4));
+  if (minutes < 90) {
+    return `about ${minutes} min left`;
+  }
+  const hours = Math.round(minutes / 60 * 10) / 10;
+  return `about ${hours} h left`;
+}
+function renderProgress(p, start2, extra) {
+  const count = p.total !== null ? `${p.done.toLocaleString()}/${p.total.toLocaleString()} ${p.unit}` : p.done > 0 ? `${p.done.toLocaleString()} ${p.unit}` : null;
+  const rate = p.ratePerMinute !== null && p.ratePerMinute > 0 ? `${Math.round(p.ratePerMinute).toLocaleString()}/min` : null;
+  const parts = [
+    `${p.phase}\u2026`,
+    count,
+    rate,
+    describeEta(p.etaAt),
+    extra ?? null,
+    p.stalled ? "no progress for 30 min" : null
+  ].filter((part) => Boolean(part));
+  const elapsed = start2 !== void 0 ? ` (${elapsedSeconds(start2)}s)` : "";
+  return `${parts.join(" \xB7 ")}${elapsed}`;
+}
 
 // src/commands/requests.ts
 var requestsSpecs = {
@@ -866,11 +947,6 @@ import { execFileSync } from "child_process";
 // src/config.ts
 var WORKSPACE_DIR = process.env["WORKSPACE_DIR"] || "/home/vercel-sandbox/workspace";
 
-// src/sleep.ts
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
 // src/ops/releases.ts
 function list3(ctx, params = {}) {
   return call(
@@ -2874,50 +2950,6 @@ import path5 from "path";
 
 // src/ops/dataSources.ts
 import { createHash as createHash2 } from "crypto";
-
-// src/poll.ts
-async function pollUntil(read, isSettled, options) {
-  const start2 = Date.now();
-  let transientSince = null;
-  while (true) {
-    let value;
-    try {
-      value = await read();
-      transientSince = null;
-    } catch (err) {
-      if (!isTransientError(err)) {
-        throw err;
-      }
-      transientSince ??= Date.now();
-      if (Date.now() - transientSince > TRANSIENT_GRACE_MS) {
-        throw err;
-      }
-      options.onProgress?.(
-        `retrying after a gateway error\u2026 (${elapsedSeconds(start2)}s)`
-      );
-      await sleep(options.pollMs);
-      continue;
-    }
-    if (isSettled(value)) {
-      return { settled: true, value };
-    }
-    if (Date.now() - start2 > options.timeoutMs) {
-      return { settled: false, value };
-    }
-    if (options.describe) {
-      options.onProgress?.(options.describe(value, start2));
-    }
-    await sleep(options.pollMs);
-  }
-}
-function elapsedSeconds(start2) {
-  return Math.round((Date.now() - start2) / 1e3);
-}
-function timedOut(timeoutMs, still) {
-  return `Timed out after ${Math.round(timeoutMs / 1e3)}s ${still}`;
-}
-
-// src/ops/dataSources.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 15 * 60 * 1e3;
 var POLL_MS2 = 3e3;
 function base(appId) {
@@ -2998,6 +3030,7 @@ async function waitForIngest(ctx, params) {
       timeoutMs,
       pollMs: POLL_MS2,
       describe: (tracked2, start2) => `ingesting\u2026 ${tracked2.length - pendingOf(tracked2).length}/${tracked2.length} done (${elapsedSeconds(start2)}s)`,
+      progressKey: (tracked2) => pendingOf(tracked2).length,
       onProgress
     }
   );
@@ -3017,33 +3050,49 @@ async function waitForIngest(ctx, params) {
     documents: tracked.map(summarize)
   };
 }
+var FAILURES_PAGE = 50;
 async function waitForCandidate(ctx, params) {
   const timeoutMs = params.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
-  const pendingOf = (docs2) => docs2.filter((d) => d.status === "processing");
   const outcome = await pollUntil(
-    () => allDocuments(ctx, { slug: params.slug, candidate: true }),
-    (docs2) => pendingOf(docs2).length === 0,
+    async () => {
+      const { dataSources } = await list8(ctx);
+      const source = dataSources.find((s) => s.slug === params.slug);
+      if (!source) {
+        throw new Error(`Data source "${params.slug}" not found.`);
+      }
+      return source.candidate?.progress ?? null;
+    },
+    (progress2) => progress2 === null || progress2.processing === 0,
     {
       timeoutMs,
       pollMs: POLL_MS2,
-      describe: (docs2, start2) => `rebuilding\u2026 ${docs2.length - pendingOf(docs2).length}/${docs2.length} done (${elapsedSeconds(start2)}s)`,
+      describe: (progress2, start2) => progress2 ? `rebuilding\u2026 ${progress2.done}/${progress2.total} done (${elapsedSeconds(start2)}s)` : `rebuilding\u2026 (${elapsedSeconds(start2)}s)`,
+      progressKey: (progress2) => progress2?.processing ?? null,
       onProgress: params.onProgress
     }
   );
-  const docs = outcome.value;
+  const counts = outcome.value;
+  const failed = counts && counts.error > 0 ? (await documents(ctx, {
+    slug: params.slug,
+    candidate: true,
+    status: "error",
+    limit: FAILURES_PAGE
+  })).documents.map(summarize) : [];
   if (!outcome.settled) {
     return {
       status: "timeout",
-      documents: docs.map(summarize),
+      counts,
+      documents: failed,
       error: timedOut(
         timeoutMs,
-        `with ${pendingOf(docs).length} document(s) still building`
+        `with ${counts?.processing ?? 0} document(s) still building`
       )
     };
   }
   return {
-    status: docs.some((d) => d.status === "error") ? "error" : "ready",
-    documents: docs.map(summarize)
+    status: counts && counts.error > 0 ? "error" : "ready",
+    counts,
+    documents: failed
   };
 }
 var DOCUMENTS_IDS_MAX = 200;
@@ -3056,7 +3105,10 @@ function documents(ctx, params) {
       candidate: params.candidate || void 0,
       ids: params.ids?.length ? params.ids.join(",") : void 0,
       limit: params.limit,
-      cursor: params.cursor
+      cursor: params.cursor,
+      order: params.order,
+      status: params.status,
+      filename: params.filename
     })}`
   );
 }
@@ -3074,7 +3126,10 @@ async function allDocuments(ctx, params) {
         candidate: params.candidate,
         ids,
         limit: 1e3,
-        cursor
+        cursor,
+        order: params.order,
+        status: params.status,
+        filename: params.filename
       });
       out2.push(...page.documents ?? []);
       cursor = page.nextCursor ?? void 0;
@@ -3165,7 +3220,10 @@ async function waitForMove(ctx, params) {
     {
       timeoutMs,
       pollMs: POLL_MS2,
-      describe: (source2, start2) => `moving\u2026 ${source2.migration.copied}/${source2.migration.total} documents (${elapsedSeconds(start2)}s)`,
+      describe: (source2, start2) => renderProgress(source2.migration.progress, start2),
+      // A corpus of any size moves as long as it keeps moving; the timeout
+      // bounds silence.
+      progressKey: (source2) => source2.migration?.copied ?? null,
       onProgress: params.onProgress
     }
   );
@@ -3359,6 +3417,9 @@ async function settle(ctx, params, isSettled) {
       timeoutMs,
       pollMs: POLL_MS3,
       describe: describeProgress,
+      // A load of any length is waited out while it moves; the timeout bounds
+      // silence. Planning moves by objects listed, a run by documents.
+      progressKey: (job2) => `${job2.state}:${job2.progress.done}`,
       onProgress: params.onProgress
     }
   );
@@ -3394,14 +3455,15 @@ async function settle(ctx, params, isSettled) {
   return { status: "done", job };
 }
 function describeProgress(job, start2) {
-  const elapsed = `(${elapsedSeconds(start2)}s)`;
-  if (job.state === "planning") {
-    return job.enumerationDone ? `planning\u2026 reading a sample of ${job.counts.objectsSeen.toLocaleString()} objects ${elapsed}` : `planning\u2026 ${job.counts.objectsSeen.toLocaleString()} objects counted ${elapsed}`;
+  if (job.state === "planning" && job.enumerationDone) {
+    return renderProgress(
+      { ...job.progress, phase: "planning" },
+      start2,
+      `reading a sample of ${job.counts.objectsSeen.toLocaleString()} objects`
+    );
   }
-  const total = job.plan?.projected.documents ?? job.counts.objectsSeen;
-  const processed = job.counts.documentsDone + job.counts.documentsSkipped + job.counts.documentsFailed;
-  const spend = `$${job.estimatedDollars.toFixed(2)}${job.budgetDollars !== null ? ` of $${job.budgetDollars.toFixed(2)}` : ""}`;
-  return `${job.state}\u2026 ${processed.toLocaleString()}/${total.toLocaleString()} documents \xB7 ${spend} ${elapsed}`;
+  const spend = job.state === "planning" ? null : `$${job.estimatedDollars.toFixed(2)}${job.budgetDollars !== null ? ` of $${job.budgetDollars.toFixed(2)}` : ""}`;
+  return renderProgress(job.progress, start2, spend);
 }
 
 // src/commands/_shared/dataSources.ts
@@ -3695,7 +3757,10 @@ async function waitForHydration(ctx, params) {
     {
       timeoutMs,
       pollMs: POLL_MS4,
-      describe: (source2, start2) => `loading\u2026 ${source2.hydration.copied}/${source2.hydration.total} documents (${elapsedSeconds(start2)}s)`,
+      describe: (source2, start2) => renderProgress(source2.hydration.progress, start2),
+      // A reload of any size is waited out while it moves; the timeout
+      // bounds silence.
+      progressKey: (source2) => source2.hydration?.copied ?? null,
       onProgress: params.onProgress
     }
   );
@@ -4359,7 +4424,9 @@ Warming and sampling:
   background; small sources reload inside the search and never show it.
   \`hydrate\` starts that reload ahead of time \u2014 before a demo, say \u2014 and
   \`--wait\` blocks until the index is back. \`datasources list\` shows the
-  reload's progress under \`hydration\`.
+  reload's progress under \`hydration\`. The same reload is what dedicated
+  capacity runs on its own after a lost node or a resume; \`infra logs\` shows
+  it start, and the source's \`hydration\` shows it land.
 
   \`sample\` draws documents from a source into a new one that shares its
   exact pinned config, so what you measure on the sample says something about
@@ -5074,8 +5141,12 @@ var dataSourcesSpecs = {
     usage: "Usage: remy-admin datasources list"
   },
   "datasources status": {
-    usage: "Usage: remy-admin datasources status [--source <slug>]",
-    flags: { source: { type: "string" } }
+    usage: "Usage: remy-admin datasources status [--source <slug>] [--status error] [--all]",
+    flags: {
+      source: { type: "string" },
+      status: { type: "string" },
+      all: { type: "boolean" }
+    }
   },
   "datasources rm": {
     usage: "Usage: remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)",
@@ -5216,10 +5287,42 @@ async function dataSourcesList(ctx) {
 }
 async function dataSourcesStatus(ctx, a) {
   const slug = sourceOf(a);
-  const documents2 = await allDocuments(ctx, { slug });
+  const status2 = a.str("status");
+  if (status2 !== void 0 && status2 !== "error") {
+    fatal("--status can only be 'error'.");
+  }
+  if (a.bool("all")) {
+    const documents2 = await allDocuments(ctx, {
+      slug,
+      ...status2 ? { status: "error" } : {}
+    });
+    out({
+      dataSource: slug,
+      documents: documents2.map(summarize)
+    });
+    return;
+  }
+  const { dataSources: sources2 } = await list8(ctx);
+  const source = sources2.find((s) => s.slug === slug);
+  if (!source) {
+    out({ dataSource: slug, exists: false });
+    return;
+  }
+  const failures = status2 === "error" || source.counts.error > 0 ? await documents(ctx, {
+    slug,
+    status: "error",
+    limit: FAILURES_PAGE
+  }) : null;
   out({
     dataSource: slug,
-    documents: documents2.map(summarize)
+    counts: source.counts,
+    chunkCount: source.chunkCount,
+    lastIngestedAt: source.lastIngestedAt,
+    activeVersion: source.activeVersion,
+    candidate: source.candidate,
+    job: source.job,
+    failures: (failures?.documents ?? []).map(summarize),
+    moreFailures: !!failures?.nextCursor
   });
 }
 async function dataSourcesRm(ctx, a) {
@@ -5515,7 +5618,8 @@ async function dataSourcesRevectorize(ctx, a) {
     dataSource: slug,
     candidateVersion: started.candidateVersion,
     status: result.status,
-    documents: result.documents,
+    counts: result.counts,
+    failures: result.documents,
     note: result.status === "error" ? "Some documents failed. Promote with --force to accept, or fix and re-run." : "Run `promote` to make this version live."
   });
   if (result.status === "error") {
@@ -5561,7 +5665,7 @@ matching passages with a citation pointing back at the source document.
 Subcommands:
   add          Add one or more documents (skips unchanged files)
   list         List data sources with document counts
-  status       Show per-document ingest state
+  status       Show a source's counts and its failed documents (--all walks every document)
   rm           Remove a document, or every document matching a filter
   search       Query a corpus \u2014 useful to sanity-check one you just built
   create       Create an empty source, optionally on dedicated capacity
@@ -5588,7 +5692,7 @@ Subcommands:
 Usage:
   remy-admin datasources add [--source <slug>] [--metadata <k=v,...>] [--wait] [--timeout <sec>] <file...>
   remy-admin datasources list
-  remy-admin datasources status [--source <slug>]
+  remy-admin datasources status [--source <slug>] [--status error] [--all]
   remy-admin datasources rm [--source <slug>] (--document <id> | --filter <k=v,...|json>)
   remy-admin datasources search [--source <slug>] [search options] <query>
   remy-admin datasources create --source <slug> [--name <name>] [--placement <resource-id|shared>] [rebuild settings...]
@@ -7501,6 +7605,21 @@ function get10(ctx, params) {
     `${base6(ctx.appId)}/${encodeURIComponent(params.id)}`
   );
 }
+function logs(ctx, params) {
+  const query3 = new URLSearchParams();
+  if (params.after) {
+    query3.set("after", params.after);
+  }
+  if (params.limit) {
+    query3.set("limit", String(params.limit));
+  }
+  const search2 = query3.toString();
+  return call(
+    ctx,
+    "GET",
+    `${base6(ctx.appId)}/${encodeURIComponent(params.id)}/logs${search2 ? `?${search2}` : ""}`
+  );
+}
 function provision(ctx, params) {
   return call(ctx, "POST", base6(ctx.appId), {
     offeringId: params.offeringId,
@@ -7554,7 +7673,14 @@ async function waitForPhase(ctx, params) {
     {
       timeoutMs,
       pollMs: POLL_MS5,
-      describe: (resource2, start2) => `${resource2.phase}${resource2.detail ? ` \xB7 ${resource2.detail}` : ""}${resource2.resizingTo ? ` \xB7 resizing to ${resource2.resizingTo.label}` : ""}\u2026 (${elapsedSeconds(start2)}s)`,
+      describe: (resource2, start2) => resource2.progress ? renderProgress(
+        resource2.progress,
+        start2,
+        resource2.resizingTo ? `resizing to ${resource2.resizingTo.label}` : null
+      ) : `${resource2.phase}${resource2.detail ? ` \xB7 ${resource2.detail}` : ""}${resource2.resizingTo ? ` \xB7 resizing to ${resource2.resizingTo.label}` : ""}\u2026 (${elapsedSeconds(start2)}s)`,
+      // A rebuild after a resume runs as long as it must; the timeout bounds
+      // silence, and a phase or step change counts as movement.
+      progressKey: (resource2) => `${resource2.phase}:${resource2.progress?.done ?? ""}:${resource2.detail ?? ""}`,
       onProgress: params.onProgress
     }
   );
@@ -7586,6 +7712,11 @@ var infraSpecs = {
     usage: "Usage: remy-admin infra get <id>",
     positionals: [{ name: "id", required: true }]
   },
+  "infra logs": {
+    usage: "Usage: remy-admin infra logs <id> [--follow] [--limit <n>]",
+    positionals: [{ name: "id", required: true }],
+    flags: { follow: { type: "boolean" }, limit: { type: "string" } }
+  },
   "infra provision": {
     usage: "Usage: remy-admin infra provision --offering <id> [--name <name>] [--wait] [--timeout <sec>]",
     flags: {
@@ -7657,6 +7788,30 @@ async function infraList(ctx, a) {
 async function infraGet(ctx, a) {
   out(await get10(ctx, { id: a.req("id") }));
 }
+var FOLLOW_POLL_MS = 4e3;
+async function infraLogs(ctx, a) {
+  const id = a.req("id");
+  const limitRaw = a.str("limit");
+  const limit = limitRaw ? Number(limitRaw) : void 0;
+  let { logs: logs2 } = await logs(ctx, { id, ...limit ? { limit } : {} });
+  out({ logs: logs2 });
+  if (!a.bool("follow")) {
+    return;
+  }
+  let after = logs2.length > 0 ? logs2[logs2.length - 1].id : void 0;
+  while (true) {
+    await new Promise((resolve2) => setTimeout(resolve2, FOLLOW_POLL_MS));
+    ({ logs: logs2 } = await logs(ctx, {
+      id,
+      ...after ? { after } : {},
+      limit: 500
+    }));
+    if (logs2.length > 0) {
+      out({ logs: logs2 });
+      after = logs2[logs2.length - 1].id;
+    }
+  }
+}
 function pricingOf(resource) {
   const offering = resource.offering;
   if (!offering) {
@@ -7755,6 +7910,7 @@ async function infraResize(ctx, a) {
 var infraHandlers = {
   "infra list": infraList,
   "infra get": infraGet,
+  "infra logs": infraLogs,
   "infra provision": infraProvision,
   "infra hibernate": infraHibernate,
   "infra resume": infraResume,
@@ -7776,7 +7932,8 @@ 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
+  get         One resource: billing to date, state timeline, recent log, attached sources
+  logs        The platform's log for a resource (--follow to keep reading)
   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
@@ -7787,6 +7944,7 @@ Subcommands:
 Usage:
   remy-admin infra list [--include-destroyed]
   remy-admin infra get <id>
+  remy-admin infra logs <id> [--follow] [--limit <n>]
   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>]
@@ -7808,26 +7966,43 @@ Placing a data source on a resource:
 
   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.
+  capacity_resuming while it moves. Once active, a source whose index is being
+  rebuilt from durable storage (after a resume, a resize or a lost node)
+  answers index_warming with the rebuild's progress and ETA until it lands;
+  \`datasources list\` shows it under hydration and the resource under
+  progress. 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.
+  A resize keeps the documents: the resource is parked, its spec is swapped,
+  and it comes back up with its sources' indexes rebuilt from durable storage
+  in the background (nothing is re-embedded). Searches on those sources answer
+  index_warming until the rebuild lands. 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.
+  (retried automatically; resume or hibernate to retry by hand). A transition
+  takes a minute or two; the rebuild that follows a resume runs under its own
+  progress with a measured ETA. --wait gives up only after --timeout (default
+  600s) WITHOUT movement, so a long rebuild is waited out while it moves.
+
+Billing and the log:
+  \`infra get\` reports resource.billing: what the resource has actually been
+  charged to date (from the ledger, exact across resizes), the hours at each
+  rate, and when it was last billed. Rates are on resource.offering.
+
+  The log is the platform's narration of the resource, not the instance's
+  stdout: each step a transition went through ("Waiting for capacity",
+  "Rebuilding archive v1 from its artifacts: 14,333,673 document(s)"), each
+  failed attempt, and each failure with the
+  pod's recent Kubernetes events and the warnings-and-errors tail of the
+  instance log at that moment (line.data). \`infra get\` includes the newest
+  200 lines; \`infra logs\` pages the rest and, with --follow, prints new lines
+  every few seconds as their own JSON document until interrupted.
 
 --wait exit codes: 0 reached the target phase \xB7 1 the platform reported failure \xB7
 2 still transitioning when --timeout elapsed (default 600s).`;

package/package.json

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