@madewithremy/admin 0.1.2 → 0.1.4

package/dist/prod.js

@@ -1887,6 +1887,82 @@ async function streamToStdout(ctx, apiPath, body) {
     }
   }
 }
+async function tailSseToStdout(ctx, apiPath) {
+  const controller = new AbortController();
+  let idleTimer;
+  let idled = false;
+  const armIdleTimer = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+    }
+    idleTimer = setTimeout(() => {
+      idled = true;
+      controller.abort();
+    }, STREAM_IDLE_TIMEOUT_MS);
+  };
+  let complete = false;
+  try {
+    armIdleTimer();
+    const res = await fetch(`${ctx.baseUrl}${apiPath}`, {
+      method: "GET",
+      headers: { ...authHeaders(ctx), Accept: "text/event-stream" },
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      fatal(
+        `API GET ${apiPath} returned ${res.status}: ${JSON.stringify(await readBody(res))}`
+      );
+    }
+    if (!res.body) {
+      fatal("Tail response has no body");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const emit = (line) => {
+      if (!line.startsWith("data: ")) {
+        return;
+      }
+      try {
+        const value = JSON.parse(line.slice(6));
+        if (value?.type === "tail_complete") {
+          complete = true;
+          return;
+        }
+        out(value);
+      } catch {
+      }
+    };
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        emit(buffer);
+        break;
+      }
+      armIdleTimer();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        emit(line);
+      }
+    }
+  } catch (err) {
+    if (complete) {
+      return;
+    }
+    if (idled || err?.name === "AbortError") {
+      fatal(
+        `Tail GET ${apiPath} stalled \u2014 no data for ${STREAM_IDLE_TIMEOUT_MS / 1e3}s`
+      );
+    }
+    throw err;
+  } finally {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+    }
+  }
+}
 
 // src/ops/methods.ts
 async function list6(ctx) {
@@ -2381,8 +2457,9 @@ var prerenderSpecs = {
     }
   },
   "prerender get": {
-    usage: "Usage: remy-admin prerender get <path>",
-    positionals: [{ name: "path", required: true }]
+    usage: "Usage: remy-admin prerender get <path> [--host <hostname>]",
+    positionals: [{ name: "path", required: true }],
+    flags: { host: { type: "string" } }
   },
   "prerender pages": {
     usage: "Usage: remy-admin prerender pages [--cursor <c>]",
@@ -2404,7 +2481,7 @@ async function prerenderGet(ctx, a) {
   const rawPath = a.req("path");
   const normalized = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
   const isDev = !ctx.baseUrl.includes("api.mindstudio.ai");
-  const host = `${ctx.appId}${isDev ? "-dev" : ""}.madewithremy.com`;
+  const host = a.str("host")?.replace(/^https?:\/\//, "").replace(/\/+$/, "") || `${ctx.appId}${isDev ? "-dev" : ""}.madewithremy.com`;
   const url = `https://${host}${normalized}`;
   const res = await fetchWithTimeout(
     url,
@@ -2448,6 +2525,7 @@ Usage:
   remy-admin prerender invalidate <path...>     Purge specific paths
   remy-admin prerender invalidate --all         Purge every snapshot for the app
   remy-admin prerender get <path>               Print { url, status, html } as a crawler sees it
+  remy-admin prerender get <path> --host <h>    Same, against a specific hostname
 
 Notes:
   - 'pages'/'view' read what's stored for the LIVE release; 'get' exercises the real
@@ -2455,12 +2533,17 @@ Notes:
     returns the live SPA and triggers a render \u2014 re-run to see it.
   - 'view' errors with snapshot_not_found when the path has no snapshot yet.
   - Invalidation targets the current LIVE release; a deploy already invalidates on its own.
+  - Mounted pages: when another app mounts this one, 'pages' lists paths carrying that
+    app's mount prefix, and those pages exist only on that app's host \u2014 pass --host to
+    verify them with 'get'. 'invalidate' takes this app's OWN paths and purges the
+    mounted copies with them.
 
 Examples:
   remy-admin prerender pages
   remy-admin prerender view /u/abc123
   remy-admin prerender invalidate --all
-  remy-admin prerender get /u/abc123`;
+  remy-admin prerender get /u/abc123
+  remy-admin prerender get /demos/vector-search/blog/x --host example.com`;
 
 // src/commands/files.ts
 import fs2 from "fs";
@@ -3781,6 +3864,209 @@ Notes:
   Transcripts ('sessions get') are the primary way to debug and iterate on a
   voice persona.`;
 
+// src/ops/agent.ts
+function threadsList(ctx, params = {}) {
+  return call(
+    ctx,
+    "GET",
+    `/_internal/v2/apps/${ctx.appId}/agent-threads${qs(params)}`
+  );
+}
+function threadsGet(ctx, threadId) {
+  return call(
+    ctx,
+    "GET",
+    `/_internal/v2/apps/${ctx.appId}/agent-threads/${seg(threadId)}`
+  );
+}
+
+// src/commands/agent.ts
+var agentSpecs = {
+  "agent threads list": {
+    usage: "Usage: remy-admin agent threads list [--limit 20] [--cursor <nextCursor>]",
+    flags: {
+      limit: { type: "number", min: 1, max: 100 },
+      cursor: { type: "string" }
+    }
+  },
+  "agent threads get": {
+    usage: "Usage: remy-admin agent threads get <threadId>",
+    positionals: [{ name: "threadId", required: true }]
+  }
+};
+async function threadsList2(ctx, a) {
+  out(
+    await threadsList(ctx, {
+      limit: a.num("limit"),
+      cursor: a.str("cursor")
+    })
+  );
+}
+async function threadsGet2(ctx, a) {
+  out(await threadsGet(ctx, a.req("threadId")));
+}
+var agentHandlers = {
+  "agent threads list": threadsList2,
+  "agent threads get": threadsGet2
+};
+var agentHelp = `remy-admin agent \u2014 Conversation log for the app's agent (chat) interface.
+
+Subcommands:
+  threads list  Every conversation, newest activity first (transcripts excluded)
+  threads get   One conversation with its full transcript
+
+Usage:
+  remy-admin agent threads list [--limit 20] [--cursor <nextCursor>]
+  remy-admin agent threads get <threadId>
+
+Examples:
+  remy-admin agent threads list --limit 10
+  remy-admin agent threads get 4f6c\u2026
+
+Notes:
+  Transcripts are how you iterate on an agent: after the user tests it, read
+  'threads get' for what was actually said and which tools ran with which
+  arguments, then fix the system prompt and tool descriptions from that evidence
+  rather than from guesses.
+
+  In the list, 'toolErrorCount' and 'hasTurnError' point at the conversations
+  worth opening \u2014 a failed tool call, or a turn that broke (model error, rate
+  limit, credits) instead of replying. 'devSession' is true for your own test
+  conversations through the dev tunnel, so you can tell them from real traffic.
+
+  In a transcript, each message is the stored conversation's own shape: 'user'
+  for a person's message and also for a tool result (which carries
+  'toolCallId'), 'assistant' for the agent (carrying 'toolCalls' when it asked
+  for tools). A method tool call also carries a 'requestId' \u2014 pass it to
+  'remy-admin requests get <requestId>' for that call's input, output, stdout
+  and error. Client tools run in the browser, so they have no requestId.`;
+
+// src/ops/events.ts
+function channelsList(ctx, params = {}) {
+  return call(
+    ctx,
+    "GET",
+    `/_internal/v2/apps/${ctx.appId}/events/channels${qs(params)}`
+  );
+}
+function publish(ctx, params) {
+  return call(
+    ctx,
+    "POST",
+    `/_internal/v2/apps/${ctx.appId}/events/publish`,
+    { channels: params.channels, data: params.data, scope: params.scope }
+  );
+}
+
+// src/commands/events.ts
+var eventsSpecs = {
+  "events tail": {
+    usage: "Usage: remy-admin events tail [<channel>] [--scope live] [--for 60]",
+    positionals: [{ name: "channel" }],
+    flags: {
+      scope: { type: "string" },
+      for: { type: "number", min: 1, max: 600 }
+    }
+  },
+  "events publish": {
+    usage: "Usage: remy-admin events publish <channel> <json> [--scope live]\nPublishes exactly as the app's own events.publish would \u2014 same validation, delivery, and metering.",
+    positionals: [
+      { name: "channel", required: true },
+      { name: "json", required: true }
+    ],
+    flags: {
+      scope: { type: "string" }
+    }
+  },
+  "events channels list": {
+    usage: "Usage: remy-admin events channels list [--scope live]",
+    flags: {
+      scope: { type: "string" }
+    }
+  }
+};
+async function eventsTail(ctx, a) {
+  const params = new URLSearchParams();
+  const channel = a.str("channel");
+  if (channel) {
+    params.set("channel", channel);
+  }
+  const scope = a.str("scope");
+  if (scope) {
+    params.set("scope", scope);
+  }
+  const forSeconds = a.num("for");
+  if (forSeconds !== void 0) {
+    params.set("forSeconds", String(forSeconds));
+  }
+  const query3 = params.toString();
+  await tailSseToStdout(
+    ctx,
+    `/_internal/v2/apps/${ctx.appId}/events/tail${query3 ? `?${query3}` : ""}`
+  );
+}
+async function eventsPublish(ctx, a) {
+  const raw = a.req("json");
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    fatal(`Invalid JSON payload: ${raw}`);
+  }
+  out(
+    await publish(ctx, {
+      channels: a.req("channel"),
+      data,
+      scope: a.str("scope")
+    })
+  );
+}
+async function eventsChannelsList(ctx, a) {
+  out(await channelsList(ctx, { scope: a.str("scope") }));
+}
+var eventsHandlers = {
+  "events tail": eventsTail,
+  "events publish": eventsPublish,
+  "events channels list": eventsChannelsList
+};
+var eventsHelp = `remy-admin events \u2014 Observe and test the app's realtime events (publish/subscribe).
+
+Subcommands:
+  tail           Print publishes live as they happen (bounded; default 60s, max 600)
+  publish        Publish a test event, exactly as the app's own events.publish would
+  channels list  Channels with recent publishes/subscriptions + live subscriber counts
+
+Usage:
+  remy-admin events tail [<channel>] [--scope live] [--for 60]
+  remy-admin events publish <channel> <json> [--scope live]
+  remy-admin events channels list [--scope live]
+
+Examples:
+  remy-admin events tail --for 30
+  remy-admin events tail jobs:usr_123
+  remy-admin events publish jobs:usr_123 '{"type":"ping"}'
+  remy-admin events channels list
+
+Notes:
+  tail answers "is my backend publishing what I think it is": run it in one
+  shell, trigger the publishing method in another, and each matching publish
+  prints as one JSON value ({channel, data, ts}). It ends on its own after
+  --for seconds (exit 0), so it is safe to run from a script.
+
+  publish lets a frontend subscriber be verified before the backend trigger
+  exists. The response's 'delivered' counts live subscriber connections per
+  published channel \u2014 0 means nobody is listening right now, which is normal,
+  not an error.
+
+  channels list is the mismatch-finder: a channel with subscribers but no
+  recent publish (or the reverse) usually means the frontend and backend spell
+  the channel differently. Window is 24h; channels are exact strings \u2014 there
+  are no wildcards anywhere in app events.
+
+  Scopes: events never cross execution environments. --scope defaults to
+  'live'; use 'dev:<devSessionId>' to inspect a tunnel session's world or
+  'preview:<releaseId>' for a branch preview.`;
+
 // src/ops/jewels.ts
 var JEWEL_RUN_TIMEOUT_MS = 6e5;
 function overview(ctx, params = {}) {
@@ -5063,6 +5349,8 @@ var SPECS = {
   ...filesSpecs,
   ...dataSourcesSpecs,
   ...voiceSpecs,
+  ...agentSpecs,
+  ...eventsSpecs,
   ...jewelsSpecs,
   ...settingsSpecs,
   ...emailSpecs,
@@ -5085,6 +5373,8 @@ var HANDLERS = {
   ...filesHandlers,
   ...dataSourcesHandlers,
   ...voiceHandlers,
+  ...agentHandlers,
+  ...eventsHandlers,
   ...jewelsHandlers,
   ...settingsHandlers,
   ...emailHandlers,
@@ -5107,6 +5397,8 @@ var GROUP_HELP = {
   files: filesHelp,
   datasources: dataSourcesHelp,
   voice: voiceHelp,
+  agent: agentHelp,
+  events: eventsHelp,
   jewels: jewelsHelp,
   settings: settingsHelp,
   email: emailHelp,
@@ -5186,6 +5478,8 @@ Commands:
   files       Store, retrieve, share (signed links) + manage files in the app's stores
   datasources Build and query searchable document corpora (RAG)
   voice       Phone numbers, voice call log + transcripts, voice policy settings
+  agent       Agent (chat) conversation log + transcripts
+  events      Realtime events \u2014 live tail, test publish, channel activity
   jewels      Monitor jewel shadowing; review + approve the proposal queue
   settings    App settings \u2014 signup allowlist, test accounts, embed origins, toggles
   email       Email \u2014 delivery log, blast stats, unsubscribes, inbox, custom domains
@@ -5216,6 +5510,8 @@ var GROUPS = [
   "files",
   "datasources",
   "voice",
+  "agent",
+  "events",
   "jewels",
   "settings",
   "email",

package/package.json

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