@madewithremy/admin 0.1.3 → 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) {
@@ -3865,6 +3941,132 @@ Notes:
   '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 = {}) {
@@ -5148,6 +5350,7 @@ var SPECS = {
   ...dataSourcesSpecs,
   ...voiceSpecs,
   ...agentSpecs,
+  ...eventsSpecs,
   ...jewelsSpecs,
   ...settingsSpecs,
   ...emailSpecs,
@@ -5171,6 +5374,7 @@ var HANDLERS = {
   ...dataSourcesHandlers,
   ...voiceHandlers,
   ...agentHandlers,
+  ...eventsHandlers,
   ...jewelsHandlers,
   ...settingsHandlers,
   ...emailHandlers,
@@ -5194,6 +5398,7 @@ var GROUP_HELP = {
   datasources: dataSourcesHelp,
   voice: voiceHelp,
   agent: agentHelp,
+  events: eventsHelp,
   jewels: jewelsHelp,
   settings: settingsHelp,
   email: emailHelp,
@@ -5274,6 +5479,7 @@ Commands:
   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
@@ -5305,6 +5511,7 @@ var GROUPS = [
   "datasources",
   "voice",
   "agent",
+  "events",
   "jewels",
   "settings",
   "email",

package/package.json

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