@remits/remits-cli 0.1.106 → 0.1.108

package/index.js

@@ -29,6 +29,7 @@ const ACCOUNT_REPO_INDEX_FILE = path.join(SESSION_DIR, 'account-repos.json');
 const SERVICE_STATE_FILE = path.join(SESSION_DIR, 'service-state.json');
 const ISSUES_DIR = path.join(SESSION_DIR, 'issues');
 const WEBSOCKET_STATE_FILE = path.join(SESSION_DIR, 'websocket-state.json');
+const LISTENER_REGISTRATION_STATE_FILE = path.join(SESSION_DIR, 'listener-registration-state.json');
 const AUTO_UPDATE_LOCK_DIR = path.join(SESSION_DIR, 'auto-update.lock');
 const AUTO_UPDATE_DISABLED_VALUES = new Set(['0', 'false', 'no', 'off']);
 const REMITS_CLI_PACKAGE_NAME = '@remits/remits-cli';
@@ -45,6 +46,10 @@ const WEBSOCKET_RECONNECT_DELAY_MS = Number(process.env.REMITS_CLI_WEBSOCKET_REC
 const WEBSOCKET_HEARTBEAT_MS = Number(process.env.REMITS_CLI_WEBSOCKET_HEARTBEAT_MS || 10000);
 const WEBSOCKET_CONNECTION_TIMEOUT_MS = Number(process.env.REMITS_CLI_WEBSOCKET_CONNECTION_TIMEOUT_MS || 15000);
 const WEBSOCKET_WATCHDOG_GRACE_MS = Number(process.env.REMITS_CLI_WEBSOCKET_WATCHDOG_GRACE_MS || 30000);
+const SUPPORT_TICKET_DASHBOARD_REFRESH_MS = Number(process.env.REMITS_CLI_SUPPORT_TICKET_REFRESH_MS || 30000);
+const SUPPORT_TICKET_DASHBOARD_LIMIT = Number(process.env.REMITS_CLI_SUPPORT_TICKET_LIMIT || 20);
+const LISTENER_REGISTRATION_INTERVAL_MS = Number(process.env.REMITS_CLI_REGISTRATION_INTERVAL_MS || 5 * 60 * 1000);
+const LISTENER_REGISTRATION_MIN_INTERVAL_MS = Number(process.env.REMITS_CLI_REGISTRATION_MIN_INTERVAL_MS || 5 * 60 * 1000);
 const ACCOUNT_SCAN_EXCLUDE_DIRS = new Set([
   '.git',
   '.gradle',
@@ -1273,6 +1278,204 @@ function discoverAccountRepos() {
   };
 }
 
+function listenerRegistrationRepoAccounts() {
+  return listAccountRepoEntries(readAccountRepoIndex())
+    .sort((a, b) => Number(a.accountId) - Number(b.accountId))
+    .map((entry) => ({
+      accountId: Number(entry.accountId),
+      name: entry.name || null,
+      type: entry.type || null,
+      platformAccountId: entry.platformAccountId || null,
+      routingScope: ['PLATFORM', 'PRODUCT'].includes(String(entry.type || '').toUpperCase())
+        ? 'self_and_descendants'
+        : 'self',
+      source: entry.source || null,
+      updatedAt: entry.updatedAt || null
+    }));
+}
+
+function readListenerRegistrationState() {
+  if (!fs.existsSync(LISTENER_REGISTRATION_STATE_FILE)) {
+    return {};
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(LISTENER_REGISTRATION_STATE_FILE, 'utf8'));
+    return data && typeof data === 'object' ? data : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function writeListenerRegistrationState(data) {
+  ensureSessionDir();
+  atomicWriteFile(LISTENER_REGISTRATION_STATE_FILE, JSON.stringify(data || {}, null, 2));
+}
+
+function listenerRegistrationStateKey(session) {
+  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const userId = session.user && session.user.id ? session.user.id : 'unknown';
+  return baseUrl + '|' + String(userId);
+}
+
+function serviceRegistrationState() {
+  const state = readServiceState();
+  return {
+    running: isListenerRunning(),
+    pid: state && state.pid ? state.pid : (fs.existsSync(LISTENER_PID_FILE) ? fs.readFileSync(LISTENER_PID_FILE, 'utf8').trim() : null),
+    startedAt: state && state.startedAt ? state.startedAt : runtimeState.service.startedAt,
+    dashboardUrl: state && state.dashboardUrl ? state.dashboardUrl : runtimeState.service.dashboardUrl
+  };
+}
+
+function listenerRegistrationPayload(session, options = {}) {
+  const service = serviceRegistrationState();
+  const groupedSessions = Array.isArray(options.groupedSessions)
+    ? options.groupedSessions.filter((entry) => entry && entry.token)
+    : [];
+  const sessionDataModes = Array.from(new Set(
+    (groupedSessions.length ? groupedSessions : [session])
+      .map((entry) => normalizeDataMode(entry && entry.dataMode))
+      .filter(Boolean)
+  )).sort();
+  const sessionAccountIds = Array.from(new Set(
+    (groupedSessions.length ? groupedSessions : [session])
+      .map((entry) => Number(entry && entry.accountId))
+      .filter((accountId) => Number.isFinite(accountId) && accountId > 0)
+  )).sort((a, b) => a - b);
+  return {
+    client: 'remits-cli',
+    reason: options.reason || 'heartbeat',
+    baseUrl: normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL),
+    accountId: Number(session.accountId),
+    dataMode: normalizeDataMode(session.dataMode),
+    dataModes: sessionDataModes,
+    sessionAccountIds,
+    registrationSessionCount: groupedSessions.length || 1,
+    websocketTopic: session.websocketTopic || (session.user && session.user.uuid ? String(session.user.uuid).replace(/-/g, '') : null),
+    dashboardUrl: service.dashboardUrl || null,
+    agent: getPreferredAgent(),
+    service,
+    repoAccounts: listenerRegistrationRepoAccounts()
+  };
+}
+
+function listenerRegistrationSignature(payload) {
+  return sha256(stableStringify({
+    baseUrl: payload.baseUrl,
+    accountId: payload.accountId,
+    dataMode: payload.dataMode,
+    dataModes: payload.dataModes || [],
+    sessionAccountIds: payload.sessionAccountIds || [],
+    websocketTopic: payload.websocketTopic,
+    dashboardUrl: payload.dashboardUrl,
+    agent: payload.agent,
+    serviceRunning: payload.service && payload.service.running,
+    repoAccounts: (payload.repoAccounts || []).map((entry) => ({
+      accountId: entry.accountId,
+      type: entry.type,
+      routingScope: entry.routingScope,
+      updatedAt: entry.updatedAt
+    }))
+  }));
+}
+
+function shouldRegisterCliListener(session, payload, options = {}) {
+  if (options.force === true) {
+    return true;
+  }
+  const state = readListenerRegistrationState();
+  const key = listenerRegistrationStateKey(session);
+  const existing = state[key];
+  if (!existing) {
+    return true;
+  }
+  const lastRegisteredAtMs = Number(existing.lastRegisteredAtMs || 0);
+  if (!lastRegisteredAtMs || Date.now() - lastRegisteredAtMs >= LISTENER_REGISTRATION_MIN_INTERVAL_MS) {
+    return true;
+  }
+  return existing.signature !== listenerRegistrationSignature(payload);
+}
+
+function rememberCliListenerRegistration(session, payload) {
+  const state = readListenerRegistrationState();
+  const key = listenerRegistrationStateKey(session);
+  state[key] = {
+    baseUrl: payload.baseUrl,
+    userId: session.user && session.user.id ? session.user.id : null,
+    signature: listenerRegistrationSignature(payload),
+    accountCount: Array.isArray(payload.repoAccounts) ? payload.repoAccounts.length : 0,
+    sessionAccountIds: payload.sessionAccountIds || [],
+    dataModes: payload.dataModes || [],
+    registrationSessionCount: payload.registrationSessionCount || 1,
+    lastRegisteredAt: new Date().toISOString(),
+    lastRegisteredAtMs: Date.now()
+  };
+  writeListenerRegistrationState(state);
+}
+
+async function registerCliListenerSession(session, options = {}) {
+  if (!session || !session.token) {
+    return null;
+  }
+  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const payload = listenerRegistrationPayload(session, options);
+  if (!shouldRegisterCliListener(session, payload, options)) {
+    return { success: true, skipped: true, reason: 'recently_registered' };
+  }
+  const api = buildAxios(baseUrl, session.token, parsePositiveInt(options.timeoutMs, 5000));
+  const response = await api.post('/cli/register', payload);
+  rememberCliListenerRegistration(session, payload);
+  return response.data;
+}
+
+async function bestEffortRegisterCliListeners(options = {}) {
+  const sessions = listSessionsFromStore(readAllSessions()).filter((session) => session && session.token);
+  if (!sessions.length) {
+    return [];
+  }
+  const groupedSessions = [];
+  for (const session of sessions) {
+    const key = listenerRegistrationStateKey(session);
+    let group = groupedSessions.find((entry) => entry.key === key);
+    if (!group) {
+      group = { key, session, sessions: [] };
+      groupedSessions.push(group);
+    }
+    group.sessions.push(session);
+  }
+
+  const results = await Promise.all(groupedSessions.map(async (group) => {
+    try {
+      const data = await registerCliListenerSession(group.session, {
+        ...options,
+        groupedSessions: group.sessions
+      });
+      return {
+        success: true,
+        accountId: group.session.accountId,
+        baseUrl: group.session.baseUrl,
+        groupedAccountIds: group.sessions.map((session) => session.accountId),
+        data
+      };
+    } catch (err) {
+      appendGlobalActivityLog('listener', 'registration.failed', {
+        accountId: group.session.accountId,
+        baseUrl: normalizeBaseUrl(group.session.baseUrl || DEFAULT_BASE_URL),
+        groupedAccountIds: group.sessions.map((session) => session.accountId),
+        error: describeError(err)
+      }, 'error');
+      return {
+        success: false,
+        accountId: group.session.accountId,
+        baseUrl: group.session.baseUrl,
+        groupedAccountIds: group.sessions.map((session) => session.accountId),
+        error: describeError(err)
+      };
+    }
+  }));
+  return results;
+}
+
 function resolvePreferredAccountId(cwd, flags, session) {
   // Explicit --account-id wins over the repo's account-info.json so users can
   // target a child account (e.g. a customer) from a parent-account repo.
@@ -1987,6 +2190,9 @@ async function authCommand(flags) {
   });
   console.log('Authenticated as user', session.user ? session.user.id : 'unknown', 'for account', session.accountId);
   console.log('Data mode:', session.dataMode);
+  try {
+    await bestEffortRegisterCliListeners({ cwd, reason: 'auth' });
+  } catch (_) { /* best-effort */ }
 
   try {
     const branchName = currentBranch(cwd);
@@ -4027,6 +4233,10 @@ let runtimeState = {
   websocket: {},
   lastAction: null
 };
+let supportTicketSnapshotCache = {
+  fetchedAtMs: 0,
+  value: null
+};
 
 function listenerSessionEntriesFromStore(store) {
   return listSessionsFromStore(store).filter((session) => session && session.token && session.websocketTopic);
@@ -4414,6 +4624,7 @@ function exportIssueBundle(snapshot) {
   copyFileIfExists(SESSIONS_FILE, path.join(globalDir, 'sessions.json'));
   copyFileIfExists(CONFIG_FILE, path.join(globalDir, 'config.json'));
   copyFileIfExists(SERVICE_STATE_FILE, path.join(globalDir, 'service-state.json'));
+  copyFileIfExists(LISTENER_REGISTRATION_STATE_FILE, path.join(globalDir, 'listener-registration-state.json'));
   copyFileIfExists(ACCOUNT_REPO_INDEX_FILE, path.join(globalDir, 'account-repos.json'));
   copyFileIfExists(DISPATCH_STATE_FILE, path.join(globalDir, 'dispatch-panes.json'));
   copyFileIfExists(TMUX_ACTIVITY_LOG_FILE, path.join(globalDir, 'tmux-activity.log'));
@@ -4455,6 +4666,7 @@ function buildGlobalFileSnapshot() {
     { label: 'config.json', path: CONFIG_FILE, mode: 'json' },
     { label: 'service-state.json', path: SERVICE_STATE_FILE, mode: 'json' },
     { label: 'websocket-state.json', path: WEBSOCKET_STATE_FILE, mode: 'json' },
+    { label: 'listener-registration-state.json', path: LISTENER_REGISTRATION_STATE_FILE, mode: 'json' },
     { label: 'dispatch-panes.json', path: DISPATCH_STATE_FILE, mode: 'json' },
     { label: 'account-repos.json', path: ACCOUNT_REPO_INDEX_FILE, mode: 'json' },
     { label: 'tmux-activity.log (tail)', path: TMUX_ACTIVITY_LOG_FILE, mode: 'tail' }
@@ -4511,7 +4723,140 @@ function buildRepoSnapshot(entry) {
   };
 }
 
-function collectDashboardSnapshot() {
+function compactSupportTicketRow(row) {
+  if (!row || typeof row !== 'object') {
+    return null;
+  }
+  return {
+    ticketId: row.ticketId || row.id || null,
+    accountId: row.accountId || row.account_id || null,
+    accountName: row.accountName || null,
+    subject: row.subject || null,
+    priority: row.priority || null,
+    status: row.status || null,
+    type: row.type || null,
+    source: row.source || null,
+    assignedTo: row.assignedTo || null,
+    implementationAccountId: row.implementationAccountId || null,
+    implementationAccountName: row.implementationAccountName || null,
+    affectedComponent: row.affectedComponent || null,
+    updatedAt: row.updatedAt || row.updated || row.lastActivityAt || null,
+    activityAt: row.activityAt || row.lastActivityAt || null,
+    activityLabel: row.activityLabel || null
+  };
+}
+
+function supportTicketQueueInput(session) {
+  return {
+    action: 'list',
+    accountId: Number(session.accountId),
+    includeChildren: true,
+    includeRoot: true,
+    sortBy: 'triage',
+    limit: Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100)
+  };
+}
+
+async function fetchSupportTicketQueueForSession(session) {
+  const baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+  const api = buildAxios(baseUrl, session.token, 12000);
+  const response = await api.post('/cli/tool', {
+    token: session.token,
+    accountId: Number(session.accountId),
+    branchName: '',
+    dataMode: 'prod',
+    name: 'mcp_support_ticket_queue',
+    callId: 'dashboard-support-ticket-queue-' + crypto.randomUUID(),
+    input: supportTicketQueueInput(session)
+  }).then((r) => r.data);
+
+  const result = response && response.result ? response.result : {};
+  const tickets = Array.isArray(result.tickets)
+    ? result.tickets.map(compactSupportTicketRow).filter(Boolean)
+    : [];
+  return {
+    success: response && response.success !== false && response.toolSuccess !== false && result.success !== false,
+    baseUrl,
+    accountId: Number(session.accountId),
+    userId: session.user && session.user.id ? session.user.id : null,
+    dataMode: result.dataMode || response.dataMode || 'prod',
+    totalCount: result.totalCount || tickets.length,
+    count: result.count || tickets.length,
+    counts: result.counts || {},
+    recommendedTicket: compactSupportTicketRow(result.recommendedTicket),
+    tickets,
+    searchedAccounts: result.searchedAccounts || [],
+    message: response.toolMessage || result.message || null
+  };
+}
+
+async function collectSupportTicketSnapshot() {
+  const nowMs = Date.now();
+  if (supportTicketSnapshotCache.value &&
+      nowMs - supportTicketSnapshotCache.fetchedAtMs < SUPPORT_TICKET_DASHBOARD_REFRESH_MS) {
+    return supportTicketSnapshotCache.value;
+  }
+
+  const sessions = listSessionsFromStore(readAllSessions())
+    .filter((session) => session && session.token && session.accountId);
+  const seen = new Set();
+  const queueSessions = sessions.filter((session) => {
+    const key = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL) + '|' + String(session.accountId) + '|' +
+      String(session.user && session.user.id ? session.user.id : '');
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  }).slice(0, 12);
+
+  const queues = [];
+  const errors = [];
+  await Promise.all(queueSessions.map(async (session) => {
+    try {
+      queues.push(await fetchSupportTicketQueueForSession(session));
+    } catch (err) {
+      errors.push({
+        baseUrl: normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL),
+        accountId: Number(session.accountId),
+        userId: session.user && session.user.id ? session.user.id : null,
+        message: describeError(err)
+      });
+    }
+  }));
+
+  const ticketsById = {};
+  for (const queue of queues) {
+    for (const ticket of queue.tickets || []) {
+      const key = String(ticket.ticketId || '');
+      if (!key || ticketsById[key]) {
+        continue;
+      }
+      ticketsById[key] = {
+        ...ticket,
+        queueAccountId: queue.accountId,
+        baseUrl: queue.baseUrl
+      };
+    }
+  }
+
+  const value = {
+    fetchedAt: new Date(nowMs).toISOString(),
+    refreshMs: SUPPORT_TICKET_DASHBOARD_REFRESH_MS,
+    queueCount: queues.length,
+    totalCount: queues.reduce((sum, queue) => sum + Number(queue.totalCount || 0), 0),
+    tickets: Object.values(ticketsById).slice(0, Math.min(Math.max(parsePositiveInt(SUPPORT_TICKET_DASHBOARD_LIMIT, 20), 1), 100)),
+    queues,
+    errors
+  };
+  supportTicketSnapshotCache = {
+    fetchedAtMs: nowMs,
+    value
+  };
+  return value;
+}
+
+async function collectDashboardSnapshot() {
   const accountRepoIndex = readAccountRepoIndex();
   const repoEntries = listAccountRepoEntries(accountRepoIndex)
     .sort((a, b) => String(a.name || '').localeCompare(String(b.name || '')))
@@ -4566,6 +4911,7 @@ function collectDashboardSnapshot() {
     globalFiles,
     repos: repoEntries,
     platformRepo,
+    supportTickets: await collectSupportTicketSnapshot(),
     issues,
     lastAction: runtimeState.lastAction
   };
@@ -4621,6 +4967,9 @@ function renderDashboardHtml(snapshot) {
           '<div id="last-action" class="empty">No dashboard actions have been triggered yet.</div>' +
         '</section>' +
       '</div>' +
+      '<div class="section-grid">' +
+        '<section class="panel"><h2>Support Tickets</h2><div id="support-ticket-section" class="accordion"></div></section>' +
+      '</div>' +
       '<div class="section-grid">' +
         '<section class="panel"><h2>Issues & Escalation</h2><div id="issues-section" class="accordion"></div></section>' +
       '</div>' +
@@ -4651,9 +5000,10 @@ function renderDashboardHtml(snapshot) {
         'function summaryItem(key,value){return \'<div class="summary-item"><span class="k">\'+escapeHtml(key)+\'</span><span class="v">\'+escapeHtml(value)+\'</span></div>\';}' +
         'function codeBlock(key,content,extraClass){return \'<pre class="code-block \'+(extraClass||"")+\'" data-scroll-key="\'+escapeHtml(key)+\'">\'+escapeHtml(content||"[missing]")+\'</pre>\';}' +
         'function detailsBlock(key,title,meta,bodyHtml,openByDefault){return \'<details class="item" data-key="\'+escapeHtml(key)+\'"\'+(openByDefault?" open":"")+\'><summary><div class="summary-main"><div class="summary-text"><span class="summary-title">\'+escapeHtml(title)+\'</span><span class="summary-meta">\'+meta+\'</span></div></div><span class="summary-caret">›</span></summary><div class="item-body">\'+bodyHtml+\'</div></details>\';}' +
-        'function renderStatusCards(state){const wsValues=Object.values((state.websocket&&state.websocket.connections)||{});const connectedCount=wsValues.filter(function(entry){return entry.status==="connected";}).length;const warnCount=wsValues.filter(function(entry){return entry.status==="connecting";}).length;const errorCount=wsValues.filter(function(entry){return entry.status==="error"||entry.status==="disconnected";}).length;const repoCount=(state.repos||[]).length;const issueCount=(state.issues||[]).length;const criticalIssueCount=(state.issues||[]).filter(function(issue){return issue.severity==="bad";}).length;const tmuxHealthy=state.tmux&&state.tmux.available&&state.tmux.sessionExists;const cards=[' +
+        'function renderStatusCards(state){const wsValues=Object.values((state.websocket&&state.websocket.connections)||{});const connectedCount=wsValues.filter(function(entry){return entry.status==="connected";}).length;const warnCount=wsValues.filter(function(entry){return entry.status==="connecting";}).length;const errorCount=wsValues.filter(function(entry){return entry.status==="error"||entry.status==="disconnected";}).length;const repoCount=(state.repos||[]).length;const issueCount=(state.issues||[]).length;const criticalIssueCount=(state.issues||[]).filter(function(issue){return issue.severity==="bad";}).length;const ticketState=state.supportTickets||{};const ticketErrors=(ticketState.errors||[]).length;const ticketTotal=ticketState.totalCount||0;const tmuxHealthy=state.tmux&&state.tmux.available&&state.tmux.sessionExists;const cards=[' +
           '{title:"Service",value:state.service&&state.service.running?"Running":"Stopped",label:"Daemon status",tone:statusTone(state.service&&state.service.running),sub:(state.service&&state.service.dashboardUrl?state.service.dashboardUrl:"No dashboard URL yet")},' +
           '{title:"Websockets",value:String(connectedCount)+"/"+String(wsValues.length||0),label:"Connected topics groups",tone:errorCount? "bad" : (warnCount? "warn" : "ok"),sub: errorCount? String(errorCount)+" unhealthy connection(s)" : (warnCount? String(warnCount)+" connecting" : "All connections healthy")},' +
+          '{title:"Tickets",value:String(ticketTotal),label:"Open support queue",tone:ticketErrors?"warn":"ok",sub:ticketErrors?String(ticketErrors)+" queue fetch error(s)":"Fetched "+String(ticketState.queueCount||0)+" queue(s)"},' +
           '{title:"Tmux",value:tmuxHealthy?"Ready":"Attention",label:"Dispatch workspace",tone:tmuxHealthy?"ok":(state.tmux&&state.tmux.available?"warn":"bad"),sub:state.tmux&&state.tmux.available?(state.tmux.sessionExists?String((state.tmux.livePanes||[]).length)+" live pane(s)":"tmux installed, session missing"):"tmux not installed"},' +
           '{title:"Issues",value:String(issueCount),label:"Detected escalation signals",tone:criticalIssueCount?"bad":(issueCount?"warn":"ok"),sub:issueCount?(criticalIssueCount?String(criticalIssueCount)+" critical signal(s)":"Review before continuing"):"No issue signals detected"},' +
           '{title:"Repos",value:String(repoCount),label:"Indexed account repos",tone:repoCount?"ok":"warn",sub:"Last scan: "+formatTime(state.discovery&&state.discovery.scannedAt)}' +
@@ -4664,15 +5014,18 @@ function renderDashboardHtml(snapshot) {
           'summaryItem("Repo Matches",String(state.discovery&&state.discovery.matches||0)),' +
           'summaryItem("Connections",String(ws.length)),' +
           'summaryItem("Topics",String(topics)),' +
+          'summaryItem("Open Tickets",String(state.supportTickets&&state.supportTickets.totalCount||0)),' +
           'summaryItem("Tracked Panes",String(tracked))' +
         '].join("");}' +
         'function renderLastAction(state){const target=document.getElementById("last-action");if(!state.lastAction){target.className="empty";target.textContent="No dashboard actions have been triggered yet.";return;}target.className="summary-item";target.innerHTML=\'<span class="k">Last Action</span><span class="v">\'+escapeHtml(state.lastAction.action||"unknown")+\'</span><div class="muted" style="margin-top:8px;">\'+escapeHtml(formatTime(state.lastAction.at))+\'</div>\'+(state.lastAction.bundlePath?\'<div class="muted" style="margin-top:8px;word-break:break-word;"><strong>Bundle:</strong> \'+escapeHtml(state.lastAction.bundlePath)+\'</div>\':"");}' +
         'function renderIssues(state){const target=document.getElementById("issues-section");const issues=state.issues||[];if(!issues.length){target.innerHTML=\'<div class="empty">No automatic issue signals are currently detected. If something still feels wrong, you can still click "Export Issue Bundle" to prepare a package for a Remits system admin.</div>\';return;}target.innerHTML=issues.map(function(issue,index){const tone=issue.severity==="bad"?"bad":"warn";const meta=badge(issue.severity==="bad"?"critical":"warning",tone)+\' <span class="muted">\'+escapeHtml(issue.scope+(issue.repoAccountId?(" account "+issue.repoAccountId):""))+\'</span>\';const evidence=(issue.evidence||[]).map(function(line){return "<li>"+escapeHtml(line)+"</li>";}).join("");const body=\'<div class="stack"><div class="muted">\'+escapeHtml(issue.summary||"")+\'</div><div class="mini-card"><strong>Recommendation</strong>\'+escapeHtml(issue.recommendation||"") + \'</div><div><strong style="display:block;margin-bottom:8px;">Evidence</strong><ul style="margin:0;padding-left:18px;display:grid;gap:8px;">\'+(evidence||"<li>No evidence lines captured.</li>")+\'</ul></div></div>\';return detailsBlock("issue:"+issue.id,(index+1)+". "+issue.title,meta,body,index===0);}).join("");}' +
+        'function renderSupportTickets(state){const target=document.getElementById("support-ticket-section");const support=state.supportTickets||{};const tickets=support.tickets||[];const queues=support.queues||[];const errors=support.errors||[];let html=\'<div class="mini-grid"><div class="mini-card"><strong>Total Open</strong>\'+escapeHtml(String(support.totalCount||0))+\'</div><div class="mini-card"><strong>Queues</strong>\'+escapeHtml(String(support.queueCount||0))+\'</div><div class="mini-card"><strong>Fetched</strong>\'+escapeHtml(formatTime(support.fetchedAt))+\'</div></div>\';if(errors.length){html+=detailsBlock("support:errors","Queue fetch errors",badge(String(errors.length)+" error(s)","warn"),codeBlock("support-errors",JSON.stringify(errors,null,2),"log"),false);}if(!queues.length&&!errors.length){target.innerHTML=html+\'<div class="empty">No authenticated support-ticket queue is available yet.</div>\';return;}const recs=queues.map(function(queue){return queue.recommendedTicket?Object.assign({queueAccountId:queue.accountId,baseUrl:queue.baseUrl},queue.recommendedTicket):null;}).filter(Boolean);if(recs.length){const recBody=recs.map(function(ticket,index){return supportTicketDetails(ticket,"support-rec:"+index);}).join("");html+=detailsBlock("support:recommended","Recommended next tickets",badge(String(recs.length)+" queue(s)","ok"),recBody,true);}if(tickets.length){html+=tickets.map(function(ticket,index){const meta=badge(ticket.priority||"priority","warn")+\' \'+badge(ticket.status||"status",ticket.status==="open"?"ok":"warn")+\' <span class="muted">\'+escapeHtml(ticket.accountName||ticket.accountId||"unknown account")+\'</span>\';return detailsBlock("support-ticket:"+ticket.ticketId,String(ticket.ticketId||"ticket")+" "+(ticket.subject||""),meta,supportTicketDetails(ticket,"support-ticket:"+index),index===0&&!recs.length);}).join("");}else{html+=\'<div class="empty">No open support tickets were returned by the current queues.</div>\';}target.innerHTML=html;}' +
+        'function supportTicketDetails(ticket,key){const command="remits-cli tool --name mcp_support_ticket --input "+JSON.stringify(JSON.stringify({action:"read",ticketId:String(ticket.ticketId||"")}))+" --data-mode prod";return \'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Ticket</strong>\'+escapeHtml(ticket.ticketId||"n/a")+\'</div><div class="mini-card"><strong>Account</strong>\'+escapeHtml((ticket.accountName||"n/a")+" ("+(ticket.accountId||"n/a")+")")+\'</div><div class="mini-card"><strong>Type</strong>\'+escapeHtml(ticket.type||"n/a")+\'</div><div class="mini-card"><strong>Assigned</strong>\'+escapeHtml(ticket.assignedTo||"unassigned")+\'</div><div class="mini-card"><strong>Implementation</strong>\'+escapeHtml((ticket.implementationAccountName||"n/a")+" ("+(ticket.implementationAccountId||"n/a")+")")+\'</div><div class="mini-card"><strong>Activity</strong>\'+escapeHtml(ticket.activityLabel||formatTime(ticket.activityAt||ticket.updatedAt))+\'</div></div><div class="muted">\'+escapeHtml(ticket.affectedComponent||"No affected component recorded.")+\'</div>\'+codeBlock(key+":cmd",command)+\'</div>\';}' +
         'function renderWebsockets(state){const entries=Object.entries((state.websocket&&state.websocket.connections)||{});const target=document.getElementById("websocket-section");if(!entries.length){target.innerHTML=\'<div class="empty">No websocket connections are registered yet.</div>\';return;}target.innerHTML=entries.map(function(pair){const baseUrl=pair[0];const info=pair[1]||{};const topicEntries=Object.entries(info.topics||{});const recentMessages=Array.isArray(info.recentMessages)?info.recentMessages:[];const tone=info.status==="connected"?"ok":(info.status==="connecting"?"warn":"bad");const summaryMeta=badge(info.status||"unknown",tone)+\' <span class="muted">\' + escapeHtml(String(topicEntries.length)) + \' topic(s)</span>\' + \' <span class="muted">\' + escapeHtml(String(recentMessages.length)) + \' recent message(s)</span>\';const topicBody=topicEntries.length?topicEntries.map(function(topicPair){const topic=topicPair[0];const topicInfo=topicPair[1]||{};const mini=\'<div class="mini-grid"><div class="mini-card"><strong>Accounts</strong>\'+escapeHtml((topicInfo.accountIds||[]).join(", ")||"n/a")+\'</div><div class="mini-card"><strong>Subscribed</strong>\'+escapeHtml(formatTime(topicInfo.subscribedAt))+\'</div><div class="mini-card"><strong>Last Message</strong>\'+escapeHtml(formatTime(topicInfo.lastMessageAt))+\'</div></div>\';return detailsBlock("ws-topic:"+baseUrl+":"+topic,topic,"topic subscription",mini,false);}).join(""):\'<div class="empty">No topic subscriptions recorded.</div>\';const messageBody=recentMessages.length?recentMessages.map(function(message,index){const messageMeta=badge(message.duplicate?"duplicate":"handled",message.duplicate?"warn":"ok")+\' <span class="muted">\'+escapeHtml(message.source||"live")+\'</span>\' + \' <span class="muted">\'+escapeHtml(message.type||"unknown-type")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Message ID</strong>\'+escapeHtml(message.messageId||"n/a")+\'</div><div class="mini-card"><strong>Timestamp</strong>\'+escapeHtml(message.timestamp?String(message.timestamp):"n/a")+\'</div><div class="mini-card"><strong>Received</strong>\'+escapeHtml(formatTime(message.receivedAt))+\'</div><div class="mini-card"><strong>Accounts</strong>\'+escapeHtml((message.accountIds||[]).join(", ")||"n/a")+\'</div></div>\'+codeBlock("ws-msg:"+baseUrl+":"+(message.messageId||index),JSON.stringify(message.payload||{},null,2)) + \'</div>\';return detailsBlock("ws-message:"+baseUrl+":"+(message.messageId||index),(message.type||"message")+" "+(message.messageId||""),messageMeta,body,false);}).join(""):\'<div class="empty">No recent websocket messages have been recorded yet.</div>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Status</strong>\'+escapeHtml(info.status||"unknown")+\'</div><div class="mini-card"><strong>Connected</strong>\'+escapeHtml(formatTime(info.connectedAt))+\'</div><div class="mini-card"><strong>Last Message</strong>\'+escapeHtml(formatTime(info.lastMessageAt))+\'</div><div class="mini-card"><strong>Last Error</strong>\'+escapeHtml(info.lastError||"none")+\'</div></div><div class="stack">\'+detailsBlock("ws-recent:"+baseUrl,"Recent messages","latest live and missed-message traffic",messageBody,false)+topicBody+\'</div></div>\';return detailsBlock("ws:"+baseUrl,baseUrl,summaryMeta,body,entries.length===1);}).join("");}' +
         'function renderTmux(state){const target=document.getElementById("tmux-section");const panes=state.tmux&&state.tmux.livePanes||[];const trackedText=state.tmux&&state.tmux.trackedPanes?state.tmux.trackedPanes:"{}";const launchSupported=state.tmux&&state.tmux.terminalLaunchSupported;const attachCommand="tmux attach -t "+(state.tmux&&state.tmux.sessionName||"remits-listener");const health=\'<div class="mini-grid"><div class="mini-card"><strong>tmux Installed</strong>\'+escapeHtml(String(state.tmux&&state.tmux.available))+\'</div><div class="mini-card"><strong>Session Exists</strong>\'+escapeHtml(String(state.tmux&&state.tmux.sessionExists))+\'</div><div class="mini-card"><strong>Session Name</strong>\'+escapeHtml(state.tmux&&state.tmux.sessionName||"n/a")+\'</div><div class="mini-card"><strong>Live Panes</strong>\'+escapeHtml(String(panes.length))+\'</div><div class="mini-card"><strong>Open from Dashboard</strong>\'+escapeHtml(launchSupported?"supported":"not supported")+\'</div></div><div class="muted" style="margin-bottom:14px;">\'+escapeHtml(launchSupported?"Use the Open Tmux Terminal button to bring Terminal forward and attach automatically.":"Dashboard-to-terminal launch is not supported on this platform. Run the attach command manually.")+\'</div>\';const quickAttach=detailsBlock("tmux:attach","Quick attach command","manual fallback",codeBlock("tmux-attach-cmd",attachCommand),false);const paneSection=detailsBlock("tmux:panes","Live panes",escapeHtml(String(panes.length))+" pane(s)",codeBlock("tmux-live-panes",JSON.stringify(panes,null,2),"log"),false);const trackedSection=detailsBlock("tmux:tracked","Tracked pane routing","ticket/task to pane mapping",codeBlock("tmux-tracked",trackedText),false);const logFile=(state.globalFiles||[]).find(function(file){return file.label==="tmux-activity.log (tail)";});const logSection=detailsBlock("tmux:activity","Activity tail","stream of tmux and websocket events",codeBlock("tmux-log",logFile&&logFile.content||"[missing]","log"),true);target.innerHTML=health+quickAttach+paneSection+trackedSection+logSection;const openButton=document.querySelector(\'[data-action="open-tmux"]\');if(openButton){openButton.disabled=!launchSupported||!(state.tmux&&state.tmux.available);}}' +
         'function renderGlobalFiles(state){const target=document.getElementById("global-files");const files=(state.globalFiles||[]).filter(function(file){return file.label!=="tmux-activity.log (tail)";});if(!files.length){target.innerHTML=\'<div class="empty">No global files found.</div>\';return;}target.innerHTML=files.map(function(file){const tone=file.exists?"ok":"warn";const meta=badge(file.exists?"present":"missing",tone)+\' <span class="muted">\'+escapeHtml(file.updatedAt?formatTime(file.updatedAt):"not found")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Path</strong>\'+escapeHtml(file.path||"")+\'</div><div class="mini-card"><strong>Size</strong>\'+escapeHtml(String(file.size||0))+\' bytes</div><div class="mini-card"><strong>Updated</strong>\'+escapeHtml(formatTime(file.updatedAt))+\'</div></div>\'+codeBlock("global:"+file.label,file.content)+(file.label==="service-state.json"?\'<div class="muted">Use this file to discover the dashboard URL and runtime websocket summary.</div>\':"")+\'</div>\';return detailsBlock("global:"+file.label,file.label,meta,body,false);}).join("");}' +
         'function renderRepos(state){const target=document.getElementById("repo-section");const repos=state.repos||[];if(!repos.length){target.innerHTML=\'<div class="empty">No indexed account repos were found. Use "Rescan Account Repos" to rebuild the index.</div>\';return;}target.innerHTML=repos.map(function(repo){const tone=repo.exists?"ok":"warn";const meta=badge(repo.exists?"available":"missing",tone)+\' <span class="muted">type: \'+escapeHtml(repo.type||"n/a")+\'</span>\';const files=(repo.files||[]).map(function(file){const fileMeta=badge(file.exists?"present":"missing",file.exists?"ok":"warn")+\' <span class="muted">\'+escapeHtml(file.updatedAt?formatTime(file.updatedAt):"not found")+\'</span>\';const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Path</strong>\'+escapeHtml(file.path||"")+\'</div><div class="mini-card"><strong>Size</strong>\'+escapeHtml(String(file.size||0))+\' bytes</div><div class="mini-card"><strong>Updated</strong>\'+escapeHtml(formatTime(file.updatedAt))+\'</div></div>\'+codeBlock("repo:"+repo.accountId+":"+file.label,file.content,file.label.indexOf("session log")>=0?"log":"")+\'</div>\';return detailsBlock("repo-file:"+repo.accountId+":"+file.label,file.label,fileMeta,body,false);}).join("");const body=\'<div class="stack"><div class="mini-grid"><div class="mini-card"><strong>Directory</strong>\'+escapeHtml(repo.directory||"")+\'</div><div class="mini-card"><strong>Source</strong>\'+escapeHtml(repo.source||"n/a")+\'</div><div class="mini-card"><strong>Platform Account</strong>\'+escapeHtml(String(repo.platformAccountId||"n/a"))+\'</div></div><div class="repo-files">\'+files+\'</div></div>\';return detailsBlock("repo:"+repo.accountId,(repo.name||"Unknown")+" ("+repo.accountId+")",meta,body,false);}).join("");}' +
-        'function renderAll(state){const detailState=saveDetailsState();const scrollState=saveScrollState();dashboardState=state;document.getElementById("generated-at").textContent=formatTime(state.generatedAt);renderStatusCards(state);renderSummary(state);renderLastAction(state);renderIssues(state);renderWebsockets(state);renderTmux(state);renderGlobalFiles(state);renderRepos(state);restoreDetailsState(detailState);restoreScrollState(scrollState);}' +
+        'function renderAll(state){const detailState=saveDetailsState();const scrollState=saveScrollState();dashboardState=state;document.getElementById("generated-at").textContent=formatTime(state.generatedAt);renderStatusCards(state);renderSummary(state);renderLastAction(state);renderSupportTickets(state);renderIssues(state);renderWebsockets(state);renderTmux(state);renderGlobalFiles(state);renderRepos(state);restoreDetailsState(detailState);restoreScrollState(scrollState);}' +
         'async function fetchState(){const res=await fetch("/api/state",{cache:"no-store"});if(!res.ok)throw new Error("State refresh failed with "+res.status);return res.json();}' +
         'function showToast(message){const toast=document.getElementById("toast");toast.textContent=message;toast.classList.add("show");clearTimeout(showToast._timer);showToast._timer=setTimeout(function(){toast.classList.remove("show");},2400);}' +
         'async function triggerAction(action,button){if(actionInFlight)return;actionInFlight=true;button.disabled=true;try{const res=await fetch("/action",{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded","Accept":"application/json"},body:"action="+encodeURIComponent(action)});if(!res.ok)throw new Error("Action failed with "+res.status);const payload=await res.json();renderAll(payload.state);if(payload.result&&payload.result.bundlePath){showToast("Issue bundle prepared at "+payload.result.bundlePath);}else{showToast(action.replace(/-/g," ")+" complete");}}catch(err){showToast(err.message||String(err));}finally{actionInFlight=false;button.disabled=false;}}' +
@@ -4731,9 +5084,10 @@ function startDashboardServer(preferredPort) {
       const requestUrl = new URL(req.url, 'http://' + DASHBOARD_HOST + ':' + (runtimeState.service.dashboardPort || preferredPort));
       if (req.method === 'GET' && requestUrl.pathname === '/api/state') {
         try {
+          const snapshot = await collectDashboardSnapshot();
           res.statusCode = 200;
           res.setHeader('Content-Type', 'application/json');
-          res.end(JSON.stringify(collectDashboardSnapshot(), null, 2));
+          res.end(JSON.stringify(snapshot, null, 2));
         } catch (err) {
           sendDashboardError(res, err, true);
         }
@@ -4756,11 +5110,13 @@ function startDashboardServer(preferredPort) {
               at: new Date().toISOString()
             };
             if (action === 'export-issues') {
-              const bundlePath = exportIssueBundle(collectDashboardSnapshot());
+              const bundlePath = exportIssueBundle(await collectDashboardSnapshot());
               actionResult = { bundlePath };
               runtimeState.lastAction.bundlePath = bundlePath;
             } else if (action === 'rescan-repos') {
               recordDiscoverySummary(discoverAccountRepos());
+              supportTicketSnapshotCache = { fetchedAtMs: 0, value: null };
+              await bestEffortRegisterCliListeners({ reason: 'dashboard.rescan' });
             } else if (action === 'open-tmux') {
               openTmuxSessionForUser();
             } else if (action === 'start-tmux') {
@@ -4777,7 +5133,7 @@ function startDashboardServer(preferredPort) {
                 success: true,
                 action,
                 result: actionResult,
-                state: collectDashboardSnapshot()
+                state: await collectDashboardSnapshot()
               }));
               return;
             }
@@ -4793,9 +5149,10 @@ function startDashboardServer(preferredPort) {
 
       if (req.method === 'GET' && requestUrl.pathname === '/') {
         try {
+          const snapshot = await collectDashboardSnapshot();
           res.statusCode = 200;
           res.setHeader('Content-Type', 'text/html; charset=utf-8');
-          res.end(renderDashboardHtml(collectDashboardSnapshot()));
+          res.end(renderDashboardHtml(snapshot));
         } catch (err) {
           sendDashboardError(res, err, false);
         }
@@ -5324,14 +5681,15 @@ function processInboundWebsocketMessage(client, baseUrl, topic, accountIds, user
       const acctId = payload.accountId || accountIds[0];
       console.log('[ws][TestSuite][account:' + acctId + ']', JSON.stringify(payload));
     }
-  } else if (data.type === 'remits-cli') {
+  } else if (data.type === 'remits-cli' || data.type === 'cli_listener' || data.type === 'listener') {
     const payload = data.payload || data;
     const dispatchAccountId = resolveDispatchAccountId(payload, accountIds[0]);
-    console.log('[ws][remits-cli][account:' + dispatchAccountId + ']', JSON.stringify(payload));
-    appendGlobalActivityLog('tmux', 'dispatch.received', {
+    console.log('[ws][listener][account:' + dispatchAccountId + ']', JSON.stringify(payload));
+    appendGlobalActivityLog('tmux', 'listener_delivery.received', {
       baseUrl,
       topic,
       accountId: dispatchAccountId,
+      messageType: data.type,
       source,
       messageId,
       message: summarizeDispatchMessage(payload)
@@ -5733,6 +6091,8 @@ async function listenCommand(flags) {
   recordDiscoverySummary(discoverAccountRepos());
   const dashboardPort = Number(flags.port || flags.dashboardPort || DEFAULT_DASHBOARD_PORT);
   await startDashboardServer(dashboardPort);
+  await bestEffortRegisterCliListeners({ reason: 'listener.start' });
+  let lastListenerRegistrationAt = Date.now();
 
   // Create the tmux session immediately so the user can attach right away
   try {
@@ -5820,6 +6180,11 @@ async function listenCommand(flags) {
         activeSessionSignature = currentSignature;
       }
 
+      if (Date.now() - lastListenerRegistrationAt >= LISTENER_REGISTRATION_INTERVAL_MS) {
+        await bestEffortRegisterCliListeners({ reason: 'listener.heartbeat' });
+        lastListenerRegistrationAt = Date.now();
+      }
+
       await runManagedWebsocketWatchdog();
       updateRuntimeServiceState();
     } catch (err) {
@@ -6213,6 +6578,9 @@ async function main() {
 
   // Best-effort: update account-repo index whenever running from inside a remits repo
   try { updateAccountRepoIndex(process.cwd()); } catch (_) { /* not in account repo */ }
+  if (!wantsJson) {
+    try { await bestEffortRegisterCliListeners({ cwd: process.cwd(), reason: 'command' }); } catch (_) { /* best-effort */ }
+  }
 
   // Auto-start the background service if not already running.
   // Skip for lifecycle subcommands and help.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remits/remits-cli",
-  "version": "0.1.106",
+  "version": "0.1.108",
   "description": "Local CLI for auth, component sync, and live test execution against Remits",
   "license": "MIT",
   "private": false,