@madewithremy/admin 0.1.24 → 0.1.26

package/README.md

@@ -1,6 +1,6 @@
 # @madewithremy/admin
 
-Admin SDK + CLI for managing production Remy apps: request logs, analytics, releases, users, secrets, database, files, email (including custom sending/receiving domains), scheduled jobs, and more. Every operation wraps the same management API the dashboard uses, so anything answerable in the console is answerable here — from the terminal or from code.
+Admin SDK + CLI for managing production Remy apps: request logs, analytics, releases, users, secrets, database, files, email (including custom sending/receiving domains), scheduled jobs, QA replays, and more. Almost every operation wraps the same management API the dashboard uses, so anything answerable in the console is answerable here — from the terminal or from code. The exception is `qa-recordings export`, which renders a video on the dev box and therefore only runs inside a sandbox.
 
 One surface, two skins: every CLI command (`remy-admin <group> <sub>`) is also a typed client method (`admin.<group>.<sub>()`). Both are thin layers over the same ops core.
 
@@ -28,6 +28,7 @@ Configuration is read from the environment and the workspace — there are no co
 | `API_BASE_URL` | API origin (default `https://api.mindstudio.ai`) |
 | `WORKSPACE_DIR` | Workspace root (default `/home/vercel-sandbox/workspace`) |
 | `${WORKSPACE_DIR}/mindstudio.json` | `appId` — which app the CLI manages |
+| `REMY_SIDECAR_URL` | Sandbox sidecar for `qa-recordings export` (default `http://127.0.0.1:4388`) |
 
 ## Import layer
 

package/dist/index.d.ts

@@ -11,6 +11,18 @@ interface AdminContext {
     apiKey: string;
     /** The app every operation is scoped to. */
     appId: string;
+    /**
+     * Who is acting, when that is not `appId` itself — set only when the caller
+     * has retargeted at another app (`--app`, or `forApp()`), and carrying the
+     * app they came FROM.
+     *
+     * Writes that record authorship attach it, so a cross-app issue says which
+     * app filed it without the caller having to remember a second flag. That
+     * matters more than it sounds: the information was always available here and
+     * being optional at the call site is precisely how it came to be omitted
+     * everywhere.
+     */
+    originAppId?: string;
     /** API origin, no trailing slash. */
     baseUrl: string;
 }
@@ -4648,7 +4660,7 @@ interface FilesLsParams {
  *   prefix: 'images/',
  * });
  */
-declare function ls(ctx: AdminContext, params: FilesLsParams): Promise<FilesLsResult>;
+declare function ls$1(ctx: AdminContext, params: FilesLsParams): Promise<FilesLsResult>;
 /**
  * Store-level summary: every store with object counts, total bytes, and
  * AV/PII scan status histograms.
@@ -4672,14 +4684,13 @@ type files_FileRef = FileRef;
 type files_FilesLsParams = FilesLsParams;
 type files_FilesPutParams = FilesPutParams;
 declare const files_fetchBytes: typeof fetchBytes;
-declare const files_ls: typeof ls;
 declare const files_put: typeof put;
 declare const files_remove: typeof remove;
 declare const files_sign: typeof sign;
 declare const files_stat: typeof stat;
 declare const files_summary: typeof summary;
 declare namespace files {
-  export { type files_FileAccess as FileAccess, type files_FileRef as FileRef, type files_FilesLsParams as FilesLsParams, type files_FilesPutParams as FilesPutParams, files_fetchBytes as fetchBytes, files_ls as ls, files_put as put, files_remove as remove, files_sign as sign, files_stat as stat, files_summary as summary };
+  export { type files_FileAccess as FileAccess, type files_FileRef as FileRef, type files_FilesLsParams as FilesLsParams, type files_FilesPutParams as FilesPutParams, files_fetchBytes as fetchBytes, ls$1 as ls, files_put as put, files_remove as remove, files_sign as sign, files_stat as stat, files_summary as summary };
 }
 
 /**
@@ -5226,9 +5237,10 @@ interface IssuesCreateParams {
     /** Labels to file it under. Open set, at most 20, 64 chars each. */
     labels?: string[];
     /**
-     * The app filing this, when it isn't the app the issue lands in. Set it when
-     * targeting another app (`forApp`) so the thread records who wrote — the
-     * recipient's reply comes back as a comment on this same issue.
+     * The app filing this, when it isn't the app the issue lands in. Defaults to
+     * `ctx.originAppId` — set whenever the caller retargeted at another app — so
+     * cross-app authorship is recorded without anyone opting in. Pass it
+     * explicitly only to override that.
      */
     originAppId?: string;
 }
@@ -6386,6 +6398,129 @@ declare namespace prerender {
   export { type prerender_PrerenderInvalidateParams as PrerenderInvalidateParams, type prerender_PrerenderPagesParams as PrerenderPagesParams, type prerender_PrerenderViewParams as PrerenderViewParams, prerender_invalidate as invalidate, prerender_pages as pages, prerender_view as view };
 }
 
+/**
+ * Response types for browser-QA replay recordings.
+ *
+ * Chunks are ordinary private files in the app's `qa-recordings` store, keyed
+ * `{sessionId}/{runId}/{seq}.json`, so `ls` here is a grouped view over
+ * `files.ls` rather than its own endpoint. Transcribed from youai-api:
+ *   src/http/routes/V2Apps/develop/recordings.ts
+ *   src/common/Recordings/sessions.ts
+ *
+ * Export is the exception — it renders on the dev box (see ../ops/recordings).
+ */
+/** One document lifetime within a session: a page load and everything after it
+ *  until the next one. Its lowest-seq chunk carries the rrweb FullSnapshot. */
+interface QaRecordingRun {
+    runId: string;
+    chunks: number;
+    bytes: number;
+    /** Store-relative keys, in seq order. */
+    keys: string[];
+}
+/** One recording session — a single tunnel process's continuous recording. */
+interface QaRecordingSession {
+    sessionId: string;
+    chunks: number;
+    bytes: number;
+    /** ISO-8601, from the chunk objects' last-modified times. */
+    startedAt?: string;
+    endedAt?: string;
+    runs: QaRecordingRun[];
+}
+interface QaRecordingsLsResult {
+    store: string;
+    sessions: QaRecordingSession[];
+    /** Present when the listing was truncated — pass it back as `cursor`. */
+    cursor?: string;
+}
+interface QaRecordingsExportResult {
+    jobId: string;
+    status: 'completed' | 'failed' | 'cancelled';
+    /** Public target only. A private one gives `store`/`key`; sign it with
+     *  `files sign` when you want a link. */
+    url?: string;
+    store?: string;
+    key?: string;
+    width?: number;
+    height?: number;
+    /** Length of the rendered clip, dead air already collapsed. */
+    durationMs?: number;
+    error?: string;
+    errorCode?: string;
+}
+
+/**
+ * Browser-QA replay recordings: list what the QA agent recorded, and render a
+ * replay to an mp4.
+ *
+ * `ls` is a grouped view over `files.ls` — a replay chunk is an ordinary
+ * private file in the app's `qa-recordings` store and needs no endpoint of its
+ * own.
+ *
+ * `export` is the one operation in this SDK that does NOT go through the
+ * management API. Rendering a replay means playing it in a real browser and
+ * encoding the frames, and the only machine set up to do that is the dev box
+ * the recording was made on: it already has the headless Chrome, the rrweb
+ * replayer and ffmpeg. So this talks to the sandbox's local sidecar, and says
+ * so plainly when there isn't one. (CLI-only paths are established here —
+ * `methods invoke --stream`, `jewels export --file` — but this is the first
+ * that needs local compute rather than local disk.)
+ */
+
+/** The app store QA replay chunks are written to (private). */
+declare const RECORDING_STORE = "qa-recordings";
+interface QaRecordingsLsParams {
+    /** Only this session. Omitted → every session in the store. */
+    sessionId?: string;
+    cursor?: string;
+    /** Chunk objects to scan, not sessions returned. */
+    limit?: number;
+}
+/**
+ * Recording sessions in this app, grouped from the chunk keys.
+ *
+ * @example
+ * const { sessions } = await admin.qaRecordings.ls({});
+ * // → [{ sessionId, chunks, bytes, runs: [{ runId, keys }] }]
+ */
+declare function ls(ctx: AdminContext, params?: QaRecordingsLsParams): Promise<QaRecordingsLsResult>;
+interface QaRecordingsExportParams {
+    /** The recording session to render (32 hex characters). */
+    sessionId: string;
+    /** Window of the session, as epoch milliseconds. Both required: a replay is
+     *  a slice of a continuous recording, not a file. */
+    from: number;
+    to: number;
+    /** Where the mp4 is written. Defaults to `assets`, public. */
+    store?: string;
+    access?: 'public' | 'private';
+    /** Milliseconds to wait for the render. */
+    timeoutMs?: number;
+}
+/**
+ * Render a window of a recording session to an mp4 on the dev box.
+ *
+ * Blocks for the whole render — the clip plays in real time, then encodes and
+ * uploads — and answers with where the video landed. Runs only on a Remy dev
+ * box, since that is where the browser and ffmpeg are.
+ *
+ * @example
+ * const { url } = await admin.qaRecordings.exportVideo({
+ *   sessionId, from: 1758000000000, to: 1758000042000,
+ * });
+ */
+declare function exportVideo(_ctx: AdminContext, params: QaRecordingsExportParams): Promise<QaRecordingsExportResult>;
+
+type qaRecordings_QaRecordingsExportParams = QaRecordingsExportParams;
+type qaRecordings_QaRecordingsLsParams = QaRecordingsLsParams;
+declare const qaRecordings_RECORDING_STORE: typeof RECORDING_STORE;
+declare const qaRecordings_exportVideo: typeof exportVideo;
+declare const qaRecordings_ls: typeof ls;
+declare namespace qaRecordings {
+  export { type qaRecordings_QaRecordingsExportParams as QaRecordingsExportParams, type qaRecordings_QaRecordingsLsParams as QaRecordingsLsParams, qaRecordings_RECORDING_STORE as RECORDING_STORE, qaRecordings_exportVideo as exportVideo, qaRecordings_ls as ls };
+}
+
 /**
  * Release operations: list, get, by-commit, dashboard live-release, and the
  * composite waitForCommit op that owns the two poll loops.
@@ -7531,7 +7666,14 @@ type BoundOps<T> = {
 declare function buildClient(ctx: AdminContext): {
     /** The resolved context this client is bound to. */
     context: Readonly<AdminContext>;
-    /** A sibling client for another app, sharing credentials. */
+    /**
+     * A sibling client for another app, sharing credentials.
+     *
+     * The app we came from becomes the origin, so a write through the returned
+     * client records which app acted — the same rule the CLI's `--app` follows.
+     * Chaining `forApp` twice keeps the FIRST app as the origin, since that is
+     * the one whose workspace this code is running in.
+     */
     forApp(appId: string): /*elided*/ any;
     agent: BoundOps<typeof agent>;
     analytics: BoundOps<typeof analytics>;
@@ -7570,6 +7712,7 @@ declare function buildClient(ctx: AdminContext): {
     jewels: BoundOps<typeof jewels>;
     methods: BoundOps<typeof methods>;
     prerender: BoundOps<typeof prerender>;
+    qaRecordings: BoundOps<typeof qaRecordings>;
     releases: BoundOps<typeof releases>;
     requests: BoundOps<typeof requests>;
     secrets: BoundOps<typeof secrets>;

package/dist/index.js

@@ -10,6 +10,7 @@ import path from "path";
 
 // src/config.ts
 var WORKSPACE_DIR = process.env["WORKSPACE_DIR"] || "/home/remy/workspace";
+var SIDECAR_URL = process.env["REMY_SIDECAR_URL"] || "http://127.0.0.1:4388";
 
 // src/parseJsonConfig.ts
 import JSON5 from "json5";
@@ -2116,6 +2117,9 @@ __export(issues_exports, {
   list: () => list8,
   reopen: () => reopen
 });
+function authorship(ctx) {
+  return ctx.originAppId ? { originAppId: ctx.originAppId } : {};
+}
 function listQuery(params) {
   return qs({
     status: params.status,
@@ -2157,8 +2161,9 @@ function create2(ctx, params) {
   if (params.labels !== void 0) {
     requestBody.labels = params.labels;
   }
-  if (params.originAppId !== void 0) {
-    requestBody.originAppId = params.originAppId;
+  const originAppId = params.originAppId ?? ctx.originAppId;
+  if (originAppId !== void 0) {
+    requestBody.originAppId = originAppId;
   }
   return call(
     ctx,
@@ -2172,13 +2177,14 @@ function comment(ctx, number, body) {
     ctx,
     "POST",
     `/_internal/v2/apps/${ctx.appId}/issues/${seg(number)}/comments`,
-    { body, authorKind: "agent" }
+    { body, authorKind: "agent", ...authorship(ctx) }
   );
 }
 function close(ctx, number, comment2) {
   const requestBody = {
     status: "closed",
-    authorKind: "agent"
+    authorKind: "agent",
+    ...authorship(ctx)
   };
   if (comment2 !== void 0) {
     requestBody.comment = comment2;
@@ -2195,11 +2201,14 @@ function reopen(ctx, number) {
     ctx,
     "POST",
     `/_internal/v2/apps/${ctx.appId}/issues/${seg(number)}/update`,
-    { status: "open", authorKind: "agent" }
+    { status: "open", authorKind: "agent", ...authorship(ctx) }
   );
 }
 function edit(ctx, number, params) {
-  const requestBody = { authorKind: "agent" };
+  const requestBody = {
+    authorKind: "agent",
+    ...authorship(ctx)
+  };
   if (params.title !== void 0) {
     requestBody.title = params.title;
   }
@@ -2407,6 +2416,112 @@ function invalidate(ctx, params = {}) {
   );
 }
 
+// src/ops/qaRecordings.ts
+var qaRecordings_exports = {};
+__export(qaRecordings_exports, {
+  RECORDING_STORE: () => RECORDING_STORE,
+  exportVideo: () => exportVideo,
+  ls: () => ls2
+});
+var RECORDING_STORE = "qa-recordings";
+async function ls2(ctx, params = {}) {
+  const page = await ls(ctx, {
+    store: RECORDING_STORE,
+    access: "private",
+    ...params.sessionId ? { prefix: `${params.sessionId}/` } : {},
+    ...params.cursor ? { cursor: params.cursor } : {},
+    ...params.limit ? { limit: params.limit } : {}
+  });
+  const sessions = /* @__PURE__ */ new Map();
+  for (const entry of page.files) {
+    const parts = entry.key.split("/");
+    if (parts.length !== 3) {
+      continue;
+    }
+    const [sessionId, runId] = parts;
+    let session = sessions.get(sessionId);
+    if (!session) {
+      session = { sessionId, chunks: 0, bytes: 0, runs: [] };
+      sessions.set(sessionId, session);
+    }
+    let run3 = session.runs.find((r) => r.runId === runId);
+    if (!run3) {
+      run3 = { runId, chunks: 0, bytes: 0, keys: [] };
+      session.runs.push(run3);
+    }
+    const size = entry.size ?? 0;
+    session.chunks += 1;
+    session.bytes += size;
+    run3.chunks += 1;
+    run3.bytes += size;
+    run3.keys.push(entry.key);
+    if (entry.updatedAt) {
+      if (!session.startedAt || entry.updatedAt < session.startedAt) {
+        session.startedAt = entry.updatedAt;
+      }
+      if (!session.endedAt || entry.updatedAt > session.endedAt) {
+        session.endedAt = entry.updatedAt;
+      }
+    }
+  }
+  for (const session of sessions.values()) {
+    for (const run3 of session.runs) {
+      run3.keys.sort((a, b) => seqOf(a) - seqOf(b));
+    }
+  }
+  return {
+    store: RECORDING_STORE,
+    sessions: [...sessions.values()].sort(
+      (a, b) => (b.endedAt ?? "").localeCompare(a.endedAt ?? "")
+    ),
+    ...page.cursor ? { cursor: page.cursor } : {}
+  };
+}
+function seqOf(key) {
+  const n = Number(
+    key.split("/").pop()?.replace(/\.json$/, "")
+  );
+  return Number.isFinite(n) ? n : 0;
+}
+var DEFAULT_EXPORT_TIMEOUT_MS = 66e4;
+async function exportVideo(_ctx, params) {
+  const body = {
+    recordingSessionId: params.sessionId,
+    startTs: params.from,
+    endTs: params.to,
+    ...params.store ? { store: params.store } : {},
+    ...params.access ? { access: params.access } : {}
+  };
+  let res;
+  try {
+    res = await fetch(`${SIDECAR_URL}/export-recording`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(
+        params.timeoutMs ?? DEFAULT_EXPORT_TIMEOUT_MS
+      )
+    });
+  } catch (err) {
+    throw new Error(
+      `Could not reach the sandbox at ${SIDECAR_URL} (${err instanceof Error ? err.message : String(err)}). Rendering a replay needs the dev box that recorded it \u2014 this command only works inside a Remy sandbox.`
+    );
+  }
+  const payload = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(
+      typeof payload.error === "string" ? payload.error : `The sandbox refused the export (HTTP ${res.status}).`
+    );
+  }
+  const status2 = payload.export;
+  if (!status2) {
+    throw new Error(
+      "The sandbox accepted the export but reported no result. Check the box's tunnel logs."
+    );
+  }
+  return status2;
+}
+
 // src/ops/requests.ts
 var requests_exports = {};
 __export(requests_exports, {
@@ -2694,9 +2809,20 @@ function buildClient(ctx) {
   return {
     /** The resolved context this client is bound to. */
     context: ctx,
-    /** A sibling client for another app, sharing credentials. */
+    /**
+     * A sibling client for another app, sharing credentials.
+     *
+     * The app we came from becomes the origin, so a write through the returned
+     * client records which app acted — the same rule the CLI's `--app` follows.
+     * Chaining `forApp` twice keeps the FIRST app as the origin, since that is
+     * the one whose workspace this code is running in.
+     */
     forApp(appId) {
-      return buildClient({ ...ctx, appId });
+      return buildClient({
+        ...ctx,
+        appId,
+        originAppId: appId === ctx.appId ? ctx.originAppId : ctx.originAppId ?? ctx.appId
+      });
     },
     agent: bindOps(agent_exports, ctx),
     analytics: bindOps(analytics_exports, ctx),
@@ -2729,6 +2855,7 @@ function buildClient(ctx) {
     jewels: bindOps(jewels_exports, ctx),
     methods: bindOps(methods_exports, ctx),
     prerender: bindOps(prerender_exports, ctx),
+    qaRecordings: bindOps(qaRecordings_exports, ctx),
     releases: bindOps(releases_exports, ctx),
     requests: bindOps(requests_exports, ctx),
     secrets: bindOps(secrets_exports, ctx),