sentinelayer-cli 0.10.2 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {

package/src/commands/session.js

@@ -2474,7 +2474,8 @@ export function registerSessionCommand(program) {
         const remote = await listSessionsFromApi({
           targetPath,
           includeArchived,
-          limit,
+          limit: emitJson ? 200 : limit,
+          fetchAll: emitJson,
         });
         const trimmed = emitJson ? remote.sessions : remote.sessions.slice(0, limit);
         const payload = {
@@ -2485,6 +2486,10 @@ export function registerSessionCommand(program) {
           ok: remote.ok,
           reason: remote.reason || "",
           count: remote.count,
+          nextCursor: remote.nextCursor || null,
+          hasMore: Boolean(remote.hasMore),
+          truncated: Boolean(remote.truncated),
+          warnings: Array.isArray(remote.warnings) ? remote.warnings : [],
           sessions: trimmed,
         };
         if (emitJson) {
@@ -2519,10 +2524,19 @@ export function registerSessionCommand(program) {
             `${item.sessionId} status=${item.status}${archive} created=${created}${lastActivity}`,
           );
         }
-        if (remote.count > trimmed.length) {
+        if (remote.count > trimmed.length || remote.hasMore) {
           console.log(
             pc.gray(
-              `… ${remote.count - trimmed.length} more (raise --limit or use --json).`,
+              remote.hasMore
+                ? "… more sessions are available (raise --limit or use --json)."
+                : `… ${remote.count - trimmed.length} more (raise --limit or use --json).`,
+            ),
+          );
+        }
+        if (remote.truncated) {
+          console.log(
+            pc.yellow(
+              "Remote session listing is truncated by the page cap; JSON output includes nextCursor for resume.",
             ),
           );
         }

package/src/session/sync.js

@@ -1243,21 +1243,27 @@ export async function pollSessionEventsBefore(
  *
  * Mirrors the failure shape of `pollHumanMessages` so callers can render
  * a single error path: `{ ok, reason, sessions, count }`. Sessions are
- * returned in API order (newest-first per the server's contract); the
+ * returned in API order (most-recently-active first per the server's contract); the
  * caller is responsible for any further sort or filter.
  *
  * @param {object} [options]
  * @param {string} [options.targetPath]
  * @param {boolean} [options.includeArchived]
  * @param {number} [options.limit]
+ * @param {string|null} [options.cursor]
+ * @param {boolean} [options.fetchAll]
+ * @param {number} [options.maxPages]
  * @param {Function} [options.resolveAuthSession]
  * @param {Function} [options.fetchImpl]
- * @returns {Promise<{ok: boolean, reason: string, sessions: Array<object>, count: number}>}
+ * @returns {Promise<{ok: boolean, reason: string, sessions: Array<object>, count: number, nextCursor: string|null, hasMore: boolean, truncated: boolean, warnings: Array<object>}>}
  */
 export async function listSessionsFromApi({
   targetPath = process.cwd(),
   includeArchived = false,
   limit = 50,
+  cursor = null,
+  fetchAll = false,
+  maxPages = 50,
   resolveAuthSession = resolveActiveAuthSession,
   fetchImpl = fetchWithTimeout,
   timeoutMs = DEFAULT_SYNC_TIMEOUT_MS,
@@ -1270,52 +1276,115 @@ export async function listSessionsFromApi({
       autoRotate: false,
     });
   } catch {
-    return { ok: false, reason: "no_session", sessions: [], count: 0 };
-  }
-  if (!session || !session.token) {
-    return { ok: false, reason: "not_authenticated", sessions: [], count: 0 };
-  }
-
-  const apiBaseUrl = resolveApiBaseUrl(session);
-  const query = new URLSearchParams();
-  if (includeArchived) query.set("include_archived", "true");
-  const normalizedLimit = Math.max(1, Math.min(200, normalizePositiveInteger(limit, 50)));
-  query.set("limit", String(normalizedLimit));
-  const endpoint = `${apiBaseUrl}/api/v1/sessions?${query.toString()}`;
-
-  let response;
-  try {
-    response = await fetchImpl(
-      endpoint,
-      {
-        method: "GET",
-        headers: { Authorization: `Bearer ${session.token}` },
-      },
-      normalizePositiveInteger(timeoutMs, DEFAULT_SYNC_TIMEOUT_MS),
-    );
-  } catch (err) {
     return {
       ok: false,
-      reason: normalizeString(err?.message) || "list_failed",
+      reason: "no_session",
       sessions: [],
       count: 0,
+      nextCursor: null,
+      hasMore: false,
+      truncated: false,
+      warnings: [],
     };
   }
-  if (!response || !response.ok) {
+  if (!session || !session.token) {
     return {
       ok: false,
-      reason: `api_${response ? response.status : "no_response"}`,
+      reason: "not_authenticated",
       sessions: [],
       count: 0,
+      nextCursor: null,
+      hasMore: false,
+      truncated: false,
+      warnings: [],
     };
   }
-  const payload = await response.json().catch(() => ({}));
-  const sessions = Array.isArray(payload?.sessions) ? payload.sessions : [];
+
+  const apiBaseUrl = resolveApiBaseUrl(session);
+  const normalizedLimit = Math.max(1, Math.min(200, normalizePositiveInteger(limit, 50)));
+  const normalizedMaxPages = Math.max(1, Math.min(100, normalizePositiveInteger(maxPages, 50)));
+  let nextCursor = normalizeString(cursor) || null;
+  let hasMore = false;
+  const sessions = [];
+  const seenSessionIds = new Set();
+  let count = 0;
+
+  for (let page = 0; page < normalizedMaxPages; page += 1) {
+    const query = new URLSearchParams();
+    if (includeArchived) query.set("include_archived", "true");
+    query.set("limit", String(normalizedLimit));
+    if (nextCursor) query.set("cursor", nextCursor);
+    const endpoint = `${apiBaseUrl}/api/v1/sessions?${query.toString()}`;
+
+    let response;
+    try {
+      response = await fetchImpl(
+        endpoint,
+        {
+          method: "GET",
+          headers: { Authorization: `Bearer ${session.token}` },
+        },
+        normalizePositiveInteger(timeoutMs, DEFAULT_SYNC_TIMEOUT_MS),
+      );
+    } catch (err) {
+      return {
+        ok: false,
+        reason: normalizeString(err?.message) || "list_failed",
+        sessions: [],
+        count: 0,
+        nextCursor: null,
+        hasMore: false,
+        truncated: false,
+        warnings: [],
+      };
+    }
+    if (!response || !response.ok) {
+      return {
+        ok: false,
+        reason: `api_${response ? response.status : "no_response"}`,
+        sessions: [],
+        count: 0,
+        nextCursor: null,
+        hasMore: false,
+        truncated: false,
+        warnings: [],
+      };
+    }
+    const payload = await response.json().catch(() => ({}));
+    const pageSessions = Array.isArray(payload?.sessions) ? payload.sessions : [];
+    for (const item of pageSessions) {
+      const sessionId = normalizeString(item?.sessionId || item?.id);
+      if (sessionId && seenSessionIds.has(sessionId)) continue;
+      if (sessionId) seenSessionIds.add(sessionId);
+      sessions.push(item);
+    }
+    count = sessions.length;
+    nextCursor = normalizeString(payload?.next_cursor || payload?.nextCursor);
+    hasMore = Boolean(payload?.has_more && nextCursor);
+    if (!fetchAll || !hasMore) break;
+  }
+
+  const truncated = Boolean(fetchAll && hasMore && nextCursor);
+  const warnings = truncated
+    ? [
+        {
+          code: "SESSION_LIST_MAX_PAGES_REACHED",
+          message: `Session list stopped after ${normalizedMaxPages} pages; output is partial and nextCursor can resume the listing.`,
+          maxPages: normalizedMaxPages,
+          nextCursor,
+        },
+      ]
+    : [];
+
   return {
     ok: true,
     reason: "",
     sessions,
-    count: typeof payload?.count === "number" ? payload.count : sessions.length,
+    count,
+    nextCursor: nextCursor || null,
+    hasMore,
+    truncated,
+    warnings,
   };
 }