@wayai/cli 0.3.158 → 0.3.159

package/dist/index.js

@@ -7376,9 +7376,26 @@ var init_contracts = __esm({
     listConversationsQuery = external_exports.object({
       hub_id: external_exports.string().uuid(),
       status: external_exports.enum(["agent", "team", "ended"]).optional(),
+      /**
+       * Last-activity window, ISO-8601 UTC, both bounds inclusive. Filters the hub
+       * conversation index on its last activity (`last_message_at`, falling back to
+       * `created_at` for a row that has no message yet) — NOT on conversation start.
+       *
+       * Activity is the axis a support-queue check needs and the one this listing
+       * already sorts by and returns as `updated_at`: `activity_to` alone answers
+       * "team conversations with nothing since X" (idle), which a start-time window
+       * cannot express at all. The ClickHouse-backed analytics list
+       * (`POST /api/analytics/conversations`) windows `created_at` instead and only
+       * ever holds ENDED conversations, so it can never answer this for `agent`/`team`.
+       */
+      activity_from: external_exports.string().datetime().optional(),
+      activity_to: external_exports.string().datetime().optional(),
       limit: external_exports.coerce.number().int().min(1).max(100).default(20),
       offset: external_exports.coerce.number().int().min(0).default(0)
-    });
+    }).refine(
+      (q) => q.activity_from === void 0 || q.activity_to === void 0 || Date.parse(q.activity_from) <= Date.parse(q.activity_to),
+      { message: "activity_from must not be after activity_to", path: ["activity_from"] }
+    );
     flagSourceSchema = external_exports.enum(["evaluator", "monitor", "both"]).nullable();
     getConversationsResponse = external_exports.object({
       conversations: external_exports.array(
@@ -9164,6 +9181,8 @@ var init_api_client = __esm({
         if (opts?.status) params.set("status", opts.status);
         if (opts?.limit) params.set("limit", String(opts.limit));
         if (opts?.offset) params.set("offset", String(opts.offset));
+        if (opts?.activityFrom) params.set("activity_from", opts.activityFrom);
+        if (opts?.activityTo) params.set("activity_to", opts.activityTo);
         return getConversationsResponse.parse(
           await this.request("GET", `/api/conversations?${params.toString()}`)
         );
@@ -10148,6 +10167,12 @@ function refineToolConfig2(value, ctx) {
     }
   }
 }
+function toIso(epochMs) {
+  return new Date(epochMs).toISOString();
+}
+function fromIso(iso) {
+  return new Date(iso).getTime();
+}
 function isIsoTimestamp2(value) {
   return typeof value === "string" && ISO_UTC_RE2.test(value);
 }
@@ -13089,9 +13114,26 @@ var init_dist = __esm({
     listConversationsQuery2 = external_exports.object({
       hub_id: external_exports.string().uuid(),
       status: external_exports.enum(["agent", "team", "ended"]).optional(),
+      /**
+       * Last-activity window, ISO-8601 UTC, both bounds inclusive. Filters the hub
+       * conversation index on its last activity (`last_message_at`, falling back to
+       * `created_at` for a row that has no message yet) — NOT on conversation start.
+       *
+       * Activity is the axis a support-queue check needs and the one this listing
+       * already sorts by and returns as `updated_at`: `activity_to` alone answers
+       * "team conversations with nothing since X" (idle), which a start-time window
+       * cannot express at all. The ClickHouse-backed analytics list
+       * (`POST /api/analytics/conversations`) windows `created_at` instead and only
+       * ever holds ENDED conversations, so it can never answer this for `agent`/`team`.
+       */
+      activity_from: external_exports.string().datetime().optional(),
+      activity_to: external_exports.string().datetime().optional(),
       limit: external_exports.coerce.number().int().min(1).max(100).default(20),
       offset: external_exports.coerce.number().int().min(0).default(0)
-    });
+    }).refine(
+      (q) => q.activity_from === void 0 || q.activity_to === void 0 || Date.parse(q.activity_from) <= Date.parse(q.activity_to),
+      { message: "activity_from must not be after activity_to", path: ["activity_from"] }
+    );
     flagSourceSchema2 = external_exports.enum(["evaluator", "monitor", "both"]).nullable();
     getConversationsResponse2 = external_exports.object({
       conversations: external_exports.array(
@@ -21773,6 +21815,140 @@ var init_eval_format = __esm({
   }
 });
 
+// src/lib/cross-hub-conversations.ts
+async function mapWithConcurrency(items, concurrency, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const runners = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await worker(items[index]);
+    }
+  });
+  await Promise.all(runners);
+  return results;
+}
+async function resolveTargets(client, orgs, errors) {
+  const perOrg = await mapWithConcurrency(orgs, CROSS_HUB_CONCURRENCY, async (org) => {
+    try {
+      const { hubs } = await client.listHubs(org.id);
+      const targets = [];
+      for (const hub of hubs) {
+        targets.push({
+          hub_id: hub.hub_id,
+          hub_name: hub.hub_name,
+          hub_environment: "preview",
+          organization_id: org.id,
+          organization_name: org.name,
+          derived: false
+        });
+        if (hub.production_hub_id) {
+          targets.push({
+            hub_id: hub.production_hub_id,
+            hub_name: hub.hub_name,
+            hub_environment: "production",
+            organization_id: org.id,
+            organization_name: org.name,
+            derived: true
+          });
+        }
+      }
+      return targets;
+    } catch (err) {
+      errors.push({
+        scope_kind: "org",
+        hub_id: null,
+        hub_name: null,
+        organization_id: org.id,
+        error: extractApiMessage(err)
+      });
+      return [];
+    }
+  });
+  const seen = /* @__PURE__ */ new Set();
+  return perOrg.flat().filter((target) => {
+    if (seen.has(target.hub_id)) return false;
+    seen.add(target.hub_id);
+    return true;
+  });
+}
+async function listConversationsAcrossHubs(client, scope, opts) {
+  const errors = [];
+  const orgs = scope.mode === "all" ? (await client.organizations()).organizations : [{ id: scope.orgId, name: null }];
+  const targets = await resolveTargets(client, orgs, errors);
+  if (targets.length > MAX_CROSS_HUB_HUBS) {
+    throw expected(
+      `${targets.length} hubs are in scope, above the ${MAX_CROSS_HUB_HUBS}-hub cap for one cross-hub listing. Narrow the scope with --org <organization_id>.`
+    );
+  }
+  const outOfScope = [];
+  let hubsRead = 0;
+  const perHub = await mapWithConcurrency(targets, CROSS_HUB_CONCURRENCY, async (target) => {
+    const { derived, ...row } = target;
+    try {
+      const result2 = await client.getConversations(target.hub_id, opts);
+      hubsRead++;
+      return result2.conversations.map((conv) => ({ ...conv, ...row }));
+    } catch (err) {
+      if (derived && isAuthorizationRefusal(err)) {
+        outOfScope.push(target.hub_id);
+        return [];
+      }
+      errors.push({
+        scope_kind: "hub",
+        hub_id: target.hub_id,
+        hub_name: target.hub_name,
+        organization_id: target.organization_id,
+        error: extractApiMessage(err)
+      });
+      return [];
+    }
+  });
+  const conversations = perHub.flat().map((row) => ({ row, key: Date.parse(row.updated_at ?? row.created_at) })).sort((a, b) => b.key - a.key).map(({ row }) => row);
+  const scopesTotal = targets.length - outOfScope.length + errors.filter((f) => f.scope_kind === "org").length;
+  const result = {
+    scope,
+    organizations_queried: orgs.length,
+    hubs_queried: targets.length,
+    hubs_read: hubsRead,
+    hubs_out_of_scope: outOfScope,
+    scopes_total: scopesTotal,
+    scopes_failed: errors.length,
+    conversations,
+    partial: errors.length > 0,
+    errors
+  };
+  assertScopeAccounting(result);
+  return result;
+}
+function isAuthorizationRefusal(err) {
+  return err instanceof ApiError && err.status === 403;
+}
+function assertScopeAccounting(result) {
+  const hubFailures = result.errors.filter((f) => f.scope_kind === "hub").length;
+  const accountedFor = result.hubs_read + result.hubs_out_of_scope.length + hubFailures;
+  if (accountedFor !== result.hubs_queried) {
+    throw new Error(
+      `cross-hub accounting: ${result.hubs_queried} hubs attempted but ${accountedFor} accounted for (read ${result.hubs_read}, out of scope ${result.hubs_out_of_scope.length}, failed ${hubFailures})`
+    );
+  }
+  if (result.partial !== result.scopes_failed > 0) {
+    throw new Error(`cross-hub accounting: partial=${result.partial} disagrees with scopes_failed=${result.scopes_failed}`);
+  }
+}
+var MAX_CROSS_HUB_HUBS, CROSS_HUB_CONCURRENCY;
+var init_cross_hub_conversations = __esm({
+  "src/lib/cross-hub-conversations.ts"() {
+    "use strict";
+    init_api_client();
+    init_errors2();
+    init_expected();
+    MAX_CROSS_HUB_HUBS = 100;
+    CROSS_HUB_CONCURRENCY = 6;
+  }
+});
+
 // src/commands/observability.ts
 async function runConversationObservability(client, hubId, conversationId, opts) {
   if (opts.messageId) {
@@ -21895,8 +22071,36 @@ var init_observability = __esm({
 // src/commands/conversations.ts
 var conversations_exports = {};
 __export(conversations_exports, {
-  conversationsCommand: () => conversationsCommand
+  conversationsCommand: () => conversationsCommand,
+  detectCrossHubScope: () => detectCrossHubScope
 });
+function detectCrossHubScope(args2) {
+  const all = args2.includes("--all");
+  const orgIdx = args2.findIndex((a) => a === "--org" || a.startsWith("--org="));
+  const inlineOrg = orgIdx !== -1 && args2[orgIdx].startsWith("--org=");
+  const orgValue = orgIdx === -1 ? void 0 : inlineOrg ? args2[orgIdx].slice("--org=".length) : args2[orgIdx + 1];
+  if (orgIdx !== -1) {
+    if (!orgValue || orgValue.startsWith("-")) {
+      console.error("--org requires an organization id (uuid). Use --all to list every organization.");
+      process.exit(1);
+    }
+    if (!UUID_RE2.test(orgValue)) {
+      console.error(`Invalid --org value: ${orgValue}. Expected an organization id (uuid).`);
+      process.exit(1);
+    }
+  }
+  if (all && orgIdx !== -1) {
+    console.error("--all and --org are mutually exclusive: --all already spans every organization.");
+    process.exit(1);
+  }
+  if ((all || orgIdx !== -1) && args2.includes("--hub")) {
+    console.error("--hub cannot be combined with --all/--org: a cross-hub listing spans every accessible hub.");
+    process.exit(1);
+  }
+  if (all) return { mode: "all" };
+  if (orgIdx !== -1) return { mode: "org", orgId: orgValue };
+  return null;
+}
 function printConversationsHelp() {
   console.error(`
 wayai conversations \u2014 list conversations or inspect what an agent received
@@ -21904,8 +22108,11 @@ wayai conversations \u2014 list conversations or inspect what an agent received
 Usage:
   wayai conversations                                  List conversations
   wayai conversations --status <agent|team|ended>      Filter by status
+  wayai conversations --status team --period 7d        Status + a last-activity window
   wayai conversations --period 7d                      Analytics-powered list
   wayai conversations --from <date> --to <date>        List within a date range
+  wayai conversations --org <organization_id>          Every hub in one organization
+  wayai conversations --all                            Every hub this login can access
   wayai conversations <conversation_id>                Show detail + messages
   wayai conversations <conversation_id> observability   List the LLM turns (per-message id, latency, tool_calls)
   wayai conversations <conversation_id> observability --message-id <id>
@@ -21923,10 +22130,32 @@ Usage:
 
 Options:
   --message-id <id>   Expand one turn (only with the \`observability\` subcommand)
-  --limit <n>         Max rows (list view)
-  --offset <n>        Skip rows (list view)
+  --limit <n>         Max rows (list view; PER HUB with --all/--org)
+  --offset <n>        Skip rows (list view; per hub with --all/--org)
   --json              Raw JSON output
 
+Time windows:
+  With \`--status\`, or with \`--all\`/\`--org\`, the listing comes from the live hub
+  index and \`--period\`/\`--from\`/\`--to\` bound LAST ACTIVITY. So
+  \`--status team --to 2026-08-22\` is "team conversations with nothing since the
+  22nd" \u2014 the idle queue. Without \`--status\` AND without \`--all\`/\`--org\`, a bare
+  \`--period\`/\`--from\`/\`--to\` still runs the ClickHouse-backed analytics list,
+  which windows conversation START and only ever holds ended conversations.
+
+Cross-hub:
+  \`--all\` / \`--org <id>\` list across the hubs \`wayai list\` enumerates PLUS the
+  production hubs those name as their parents. Two different cases end in a hub
+  going unread, and they are reported differently:
+    - A production PARENT this login cannot read is NAMED as skipped and does not
+      make the run fail \u2014 it is a standing property of the login, not an outage.
+    - A production hub whose PREVIEW this login cannot see is not enumerable
+      anywhere, so it is not covered and NOT reported at all. Reach it with
+      \`--hub <id>\`.
+  Each hub is read with the caller's own grants; a hub IN SCOPE that refuses is
+  reported and the listing exits non-zero as partial rather than looking like a
+  smaller queue, and an empty scope is reported as such, never as an empty queue.
+  \`--org\` accepts \`--org <id>\` and \`--org=<id>\`.
+
 The default text list omits message ids \u2014 use \`--json\` or the \`observability\`
 subcommand to discover them. \`observability\` is the answer to "the agent did X \u2014
 what did it ACTUALLY see?".
@@ -21937,9 +22166,10 @@ async function conversationsCommand(args2) {
     printConversationsHelp();
     return;
   }
-  const hubId = resolveActiveHubId(args2);
+  const crossHubScope = detectCrossHubScope(args2);
+  const hubId = crossHubScope ? "" : resolveActiveHubId(args2);
   const { config, accessToken } = await requireAuth();
-  requireRepoConfig();
+  if (!crossHubScope) requireRepoConfig();
   let status;
   let conversationId;
   let subcommand;
@@ -22012,6 +22242,9 @@ async function conversationsCommand(args2) {
       }
     } else if (arg === "--json") {
       jsonOutput = true;
+    } else if (arg === "--all" || arg.startsWith("--org=")) {
+    } else if (arg === "--org") {
+      i++;
     } else if (!arg.startsWith("-")) {
       if (conversationId === void 0 && arg === "observability") {
         subcommand = arg;
@@ -22027,6 +22260,10 @@ async function conversationsCommand(args2) {
   }
   const client = new ApiClient({ apiUrl: config.api_url, accessToken });
   const hasAnalyticsFlags = !!(period || from || to);
+  if (crossHubScope && (conversationId || subcommand)) {
+    console.error("--all/--org apply to the conversation LIST only. Drop them and pass --hub <id> to open one conversation.");
+    process.exit(1);
+  }
   if (subcommand === "observability") {
     if (!conversationId) {
       console.error("Usage: wayai conversations <conversation_id> observability [--message-id X] [--json]");
@@ -22152,11 +22389,65 @@ async function conversationsCommand(args2) {
     }
     console.log("Diagnosing agent behavior? The transcript shows what was sent \u2014 not what the model received.");
     console.log(`Drill in:  wayai conversations ${conversationId} observability   (per-turn resolved prompt, tool calls, latency)`);
-  } else if (hasAnalyticsFlags) {
-    if (status) {
-      console.error("The --status flag is not supported with --period/--from/--to. Without these flags, --status works as before.");
+  } else if (crossHubScope) {
+    const window = resolveActivityWindow(period, from, to);
+    const result = await listConversationsAcrossHubs(client, crossHubScope, {
+      status,
+      limit,
+      offset,
+      activityFrom: window.start,
+      activityTo: window.end
+    });
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      if (result.partial || result.hubs_queried === 0) process.exit(1);
+      return;
+    }
+    for (const failure of result.errors) {
+      const where = failure.scope_kind === "hub" ? `hub ${sanitizeTerminalText(failure.hub_name || failure.hub_id || "")} (${failure.hub_id})` : `organization ${failure.organization_id}`;
+      console.error(`Could not read ${where}: ${sanitizeTerminalText(failure.error)}`);
+    }
+    if (result.hubs_queried === 0) {
+      console.error(
+        `No hubs were in scope across ${result.organizations_queried} organization(s), so no queue was read. \`wayai list\` shows the hubs this login can enumerate; use \`--hub <id>\` for one hub outside that set.`
+      );
       process.exit(1);
     }
+    if (result.hubs_out_of_scope.length > 0) {
+      const ids = result.hubs_out_of_scope.map(sanitizeTerminalText).join(", ");
+      console.error(
+        `Note: ${result.hubs_out_of_scope.length} production hub(s) are outside this login's grants and were not read: ${ids}. Reach one with --hub <id>.`
+      );
+    }
+    if (result.conversations.length === 0) {
+      console.log(`No conversations found across ${result.hubs_read} hub(s).`);
+    } else {
+      console.log(`Conversations (${result.conversations.length} across ${result.hubs_read} hubs):
+`);
+      for (const conv of result.conversations) {
+        const user = sanitizeTerminalText(conv.user_name || conv.user_email || "unknown");
+        const updated = conv.updated_at ? new Date(conv.updated_at).toLocaleString() : "-";
+        const env = conv.hub_environment === "production" ? "prod" : "prev";
+        const hub = truncate(sanitizeTerminalText(conv.hub_name || conv.hub_id), HUB_COL_WIDTH);
+        console.log(`  ${hub.padEnd(HUB_COL_WIDTH)}  ${env}  ${conv.conversation_id}  ${conv.conversation_status.padEnd(7)}  ${user.padEnd(20)}  ${updated}`);
+      }
+    }
+    if (result.partial) {
+      console.error(`
+Partial listing: ${result.scopes_failed} of ${result.scopes_total} scope(s) could not be read.`);
+      process.exit(1);
+    }
+  } else if (status && hasAnalyticsFlags) {
+    const window = resolveActivityWindow(period, from, to);
+    const result = await client.getConversations(hubId, {
+      status,
+      limit,
+      offset,
+      activityFrom: window.start,
+      activityTo: window.end
+    });
+    printIndexList(result, jsonOutput);
+  } else if (hasAnalyticsFlags) {
     if (from && !to || !from && to) {
       console.error("--from and --to must both be provided together.");
       process.exit(1);
@@ -22211,28 +22502,62 @@ async function conversationsCommand(args2) {
     }
   } else {
     const result = await client.getConversations(hubId, { status, limit, offset });
-    if (jsonOutput) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
+    printIndexList(result, jsonOutput);
+  }
+}
+function printIndexList(result, jsonOutput) {
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.conversations.length === 0) {
+    console.log("No conversations found.");
+    return;
+  }
+  console.log(`Conversations (${result.conversations.length} of ${result.total}):
+`);
+  for (const conv of result.conversations) {
+    const user = conv.user_name || conv.user_email || "unknown";
+    const updated = conv.updated_at ? new Date(conv.updated_at).toLocaleString() : "-";
+    const kanban = truncate(
+      conv.outcome ? `${conv.kanban_status ?? "-"}/${conv.outcome}` : conv.kanban_status ?? "-",
+      KANBAN_COL_WIDTH
+    );
+    console.log(`  ${conv.conversation_id}  ${conv.conversation_status.padEnd(7)}  ${kanban.padEnd(KANBAN_COL_WIDTH)}  ${user.padEnd(20)}  ${updated}`);
+  }
+}
+function resolveActivityWindow(period, from, to) {
+  let start;
+  let end;
+  if (from || to) {
+    try {
+      start = from ? canonicalIso(parseDateArg(from, "from")) : void 0;
+      end = to ? canonicalIso(parseDateArg(to, "to")) : void 0;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
     }
-    if (result.conversations.length === 0) {
-      console.log("No conversations found.");
-      return;
+    if (start && end && Date.parse(start) > Date.parse(end)) {
+      console.error("--from must be before --to.");
+      process.exit(1);
     }
-    console.log(`Conversations (${result.conversations.length} of ${result.total}):
-`);
-    for (const conv of result.conversations) {
-      const user = conv.user_name || conv.user_email || "unknown";
-      const updated = conv.updated_at ? new Date(conv.updated_at).toLocaleString() : "-";
-      const kanban = truncate(
-        conv.outcome ? `${conv.kanban_status ?? "-"}/${conv.outcome}` : conv.kanban_status ?? "-",
-        KANBAN_COL_WIDTH
-      );
-      console.log(`  ${conv.conversation_id}  ${conv.conversation_status.padEnd(7)}  ${kanban.padEnd(KANBAN_COL_WIDTH)}  ${user.padEnd(20)}  ${updated}`);
+    return { start, end };
+  }
+  if (period) {
+    try {
+      const parsed = parsePeriod(period);
+      return { start: parsed.start, end: parsed.end };
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
     }
   }
+  return {};
+}
+function canonicalIso(value) {
+  return toIso(fromIso(value));
 }
-var KANBAN_COL_WIDTH;
+var KANBAN_COL_WIDTH, HUB_COL_WIDTH;
 var init_conversations = __esm({
   "src/commands/conversations.ts"() {
     "use strict";
@@ -22242,8 +22567,12 @@ var init_conversations = __esm({
     init_api_client();
     init_utils();
     init_eval_format();
+    init_terminal_output();
+    init_cross_hub_conversations();
     init_observability();
+    init_dist();
     KANBAN_COL_WIDTH = 30;
+    HUB_COL_WIDTH = 24;
   }
 });