ccdeck 3.44.0 → 3.45.0

package/dist/web/assets/{index-BQbOfxbL.js → index-r8Ymr47Q.js}

@@ -1 +1 @@
-import"./app-CQIstkMF.js";(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const e of document.querySelectorAll('link[rel="modulepreload"]'))i(e);new MutationObserver(e=>{for(const r of e)if(r.type==="childList")for(const o of r.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function s(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?r.credentials="include":e.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function i(e){if(e.ep)return;e.ep=!0;const r=s(e);fetch(e.href,r)}})();
+import"./app-BW3NYUYB.js";(function(){const t=document.createElement("link").relList;if(t&&t.supports&&t.supports("modulepreload"))return;for(const e of document.querySelectorAll('link[rel="modulepreload"]'))i(e);new MutationObserver(e=>{for(const r of e)if(r.type==="childList")for(const o of r.addedNodes)o.tagName==="LINK"&&o.rel==="modulepreload"&&i(o)}).observe(document,{childList:!0,subtree:!0});function s(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),e.crossOrigin==="use-credentials"?r.credentials="include":e.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function i(e){if(e.ep)return;e.ep=!0;const r=s(e);fetch(e.href,r)}})();

package/dist/web/index.html

@@ -77,9 +77,9 @@
         document.documentElement.setAttribute("data-density", density === "tightest" || density === "tighter" || density === "compact" || density === "comfortable" ? density : "default");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BQbOfxbL.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/app-CQIstkMF.js">
-    <link rel="stylesheet" crossorigin href="/assets/app-Ch-0CYlK.css">
+    <script type="module" crossorigin src="/assets/index-r8Ymr47Q.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/app-BW3NYUYB.js">
+    <link rel="stylesheet" crossorigin href="/assets/app-C5RY_wZ4.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.44.0",
+  "version": "3.45.0",
   "description": "Local dashboard for Claude Code and Codex CLI sessions: which Claude Code session needs input, every tool call and Claude Code subagent live, token cost and quota, several Claude accounts. Run npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -80,6 +80,24 @@
     "3.43.1",
     "3.43.3"
   ],
+  "3.45.0": [
+    {
+      "title": "🔗 Read-only Jira, GitHub and GitLab panels beside your agents",
+      "body": "Settings › Integrations connects Jira (Cloud, Server or Data Center), GitHub, and GitLab.com or your own GitLab, each with a token, and a control on the left stripe opens its panel: a Jira board's backlog in Jira's own order, or a project's branches, pull or merge requests, pipelines and issues, with the item beside the list. The panels only read: they never comment, merge, re-run a job or change an issue. The token stays on this machine, in a file only you can read, and goes only to that connection's own API. Nothing is read until you connect a tracker, and then only while its panel is open."
+    },
+    {
+      "title": "📤 Each account says what its organization's telemetry sends",
+      "body": "A Team or Enterprise organization can turn on Claude Code's telemetry for every member, and Claude Code applies it without asking. Each account of such an organization now carries a line under its name: “Telemetry · usage data”, or “Telemetry · prompts, tool details” in the warning colour when your prompts and tool details are sent too. Its tooltip names the organization and where the data goes. After a switch, Auto-switch's notification and the row's “Now active” note say it too. The deck changes nothing; it learns what the organization turns on from a Claude Code session run on one of its accounts, and until then that account shows no line."
+    },
+    {
+      "title": "⚠️ A warning when a paired deck is on the same Claude login",
+      "body": "A Claude login renews once, so when two machines use one copied login, the one that renews second is signed out. When a paired deck on Local network says it is on the login this deck is using, the live account's row now says “Also active on” and names that deck, with what to do: use a different account on one of the machines, or sign in on each one separately. A switch onto such a login says so too, and so does one desktop notification per incident, “Login active on another deck” in Settings › Notifications, which is on by default."
+    },
+    {
+      "title": "📱 A phone opens one panel at most when the deck loads",
+      "body": "On a window 640 px wide or less, a reload used to open Accounts, Usage and the machine panel on top of each other, with none of the board in sight. It now opens at most one of them, preferring Usage over the machine panel, and Accounts and the session list open from the dock. A wider window loads exactly as before, and nothing you chose is forgotten."
+    }
+  ],
   "3.44.0": [
     {
       "title": "⛔ A turn that stops on an error now shows as stopped",

package/src/server/account-notify.mjs

@@ -1,4 +1,4 @@
-// Four notifications about the accounts the deck is on, and the rules for when
+// Five notifications about the accounts the deck is on, and the rules for when
 // each is said.
 //
 //   SWAP       the deck's own auto-switch tick moved the live Claude account.
@@ -13,6 +13,11 @@
 //              every session on the machine shares the login, so they stop
 //              together — with how many stopped and that each needs a
 //              "continue" once a working login is active.
+//   ELSEWHERE  the Claude account this deck is on is the one a paired deck says
+//              it is on too (#2192). Said once per incident — from the moment
+//              both are on it until one of them is not — because the next
+//              renewal signs one of the two machines out, and nothing on the
+//              desktop says so before it does. See lan-elsewhere.mjs.
 //
 // SPARSE BY CONSTRUCTION. Each window is a record keyed by provider, account
 // and window, holding the reset instant it is about and the levels already said
@@ -42,6 +47,7 @@
 // injected — the shape block-notify.mjs uses, for the reason it gives: what the
 // suite cannot run is what drifts.
 import { switchCanCure } from "./stop-failure.mjs";
+import { deckList } from "./lan-elsewhere.mjs";
 
 /** The levels a window is announced at, lowest first. */
 export const LEVELS = Object.freeze([90, 100]);
@@ -403,6 +409,23 @@ export function stuckNotice({ fromName }) {
   return { who: SWAP_WHO, body: `${from}'s login expired · no other account is ready to switch to` };
 }
 
+/**
+ * "Claude · work@x.com", "Also active on iMac. When one machine renews this
+ * login, the other is signed out — use a different account on one of them."
+ *
+ * The decks by the names Local network's list gives them. The reason is the
+ * sentence, because it is the whole of why this is worth a notification: the
+ * same account on two machines is ordinary, one copied login live on two is
+ * what breaks, and the remedy is one press on either machine.
+ */
+export function elsewhereNotice({ accountName, decks }) {
+  return {
+    who: whoFor("claude", accountName),
+    body: `Also active on ${cut(deckList(decks), NAME_MAX)}. When one machine renews this login, the other is `
+      + "signed out — use a different account on one of them.",
+  };
+}
+
 /** The records, as read back from disk: anything that is not one is dropped,
  *  and so is one nobody has read for RECORD_KEEP_MS. */
 export function normaliseRecords(raw, now) {
@@ -435,9 +458,9 @@ function laterUnref(fn, ms) {
  *
  *   notify(title, body, meta)  the OS call — injected, never awaited by a poll
  *                              or a tick, and its failure goes to `onError`
- *   settings()                 `{ swap, quota, reset, stopped }`, asked per
- *                              decision, so a switch pressed mid-run takes
- *                              effect at once
+ *   settings()                 `{ swap, quota, reset, stopped, elsewhere }`,
+ *                              asked per decision, so a switch pressed mid-run
+ *                              takes effect at once
  *   load() / save(records)     the disk, both best effort
  *   now, later                 the clock and the hold timer, for the suite
  *
@@ -459,6 +482,11 @@ export function createAccountNotifier({
   let policy = null;
   /** Threshold notices held for a tick, by record key. */
   const held = new Map();
+  /** The account whose ELSEWHERE incident is open — this deck and another on
+   *  it — and therefore already said, or null. One at a time, because this
+   *  deck is on one account at a time. Kept in memory: a restart in the middle
+   *  of an incident says it once more, which is a restart's news as well. */
+  let elsewhereOpen = null;
   let holdTimer = null;
   let saving = Promise.resolve();
   /** The stop incident being gathered or held, or the one already said while
@@ -617,8 +645,13 @@ export function createAccountNotifier({
    * `{ email, organizationUuid, alias }` — read after the tick, for the names
    * and the keys of the two accounts a switch moved between. `startedAt` is
    * when the tick began, which decides whether it can answer for a stop.
+   *
+   * `telemetryOf`, when given, answers what an organization's telemetry
+   * settings turn on, as one sentence or null (org-telemetry.mjs's
+   * telemetryClause): the swap notice carries it for the account it moved to,
+   * because an unattended switch is exactly when nobody saw it coming.
    */
-  async function tick(result, accounts, { startedAt = null } = {}) {
+  async function tick(result, accounts, { startedAt = null, telemetryOf = null } = {}) {
     try {
       await ready;
       if (!result || typeof result !== "object") return;
@@ -686,7 +719,12 @@ export function createAccountNotifier({
           cured.said = true;
           if (cured.timer) { clearTimeout(cured.timer); cured.timer = null; }
         }
-        say(cured && s.stopped ? withStopped(notice, cured.ids.size) : notice);
+        const told = cured && s.stopped ? withStopped(notice, cured.ids.size) : notice;
+        // Only for an account the store and the tick agree on: an organization
+        // read off the wrong slot would put another company's policy on it.
+        const toOrg = to?.key ? accounts?.[String(result.to?.number)]?.organizationUuid : null;
+        const telemetry = toOrg && telemetryOf ? telemetryOf(toOrg) : null;
+        say(telemetry ? { ...told, body: `${told.body}\n${telemetry}` } : told);
       }
       await persist();
     } catch (err) {
@@ -721,11 +759,35 @@ export function createAccountNotifier({
     }
   }
 
+  /**
+   * What Local network says about the account this deck is on: `account` is
+   * `{ key, name }`, or null when this deck is on none, and `decks` the paired
+   * decks that say they are on it too, by name.
+   *
+   * ONCE PER INCIDENT. The incident opens when both are on it, is said then —
+   * if the switch is on at that moment — and closes when either moves off it
+   * or the other deck stops saying so (lan-elsewhere.mjs holds a deck's word
+   * for five minutes, which is what keeps a dropped round from closing it). A
+   * new one is news again; the same one, every minute, is not.
+   */
+  async function elsewhere(account, decks) {
+    try {
+      await ready;
+      const key = account?.key && Array.isArray(decks) && decks.length > 0 ? account.key : null;
+      if (key === elsewhereOpen) return;
+      elsewhereOpen = key;
+      if (key && settings().elsewhere) say(elsewhereNotice({ accountName: account.name, decks }));
+    } catch (err) {
+      onError?.(err);
+    }
+  }
+
   return {
     ready,
     observe,
     tick,
     stopped,
+    elsewhere,
     /** The loop was switched on or off. Off, nothing will carry what is held. */
     autoSwitch(on) {
       autoOn = on === true;

package/src/server/account-watch.mjs

@@ -24,6 +24,10 @@ import { writeFileAtomic } from "./atomic-write.mjs";
 // What a StopFailure says, and the words a notification names a session by.
 import { stopFailureOf, switchCanCure } from "./stop-failure.mjs";
 import { whoOf } from "./block-notify.mjs";
+// Which deck is on what, as Local network last heard it, and the identity rule
+// its keys are made by (#2192).
+import { elsewhereNow } from "./lan-elsewhere.mjs";
+import { accountKey } from "./lan-copies.mjs";
 
 const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -42,10 +46,19 @@ export function recordsPath(home = deckDataDir()) {
  */
 export const WATCH_MS = 2 * 60_000;
 
+/**
+ * How often the notifier asks Local network whether the account this deck is
+ * on is live on another deck too (#2192). A round is a minute, so asking more
+ * often finds nothing new; and with no deck on any account of this one's, the
+ * look is the engine's status and nothing else — the store is not read.
+ */
+export const ELSEWHERE_WATCH_MS = 60_000;
+
 let _deps = null;
 let _notifier = null;
 let _autoOn = false;
 let _timer = null;
+let _elsewhereTimer = null;
 let _watching = null;
 /** The auto-switch loop's "tick now", handed in by the loop as it loads
  *  (cswap-auto-loop.mjs `tickSoon`). Null until then, and on a deck that never
@@ -110,11 +123,23 @@ export function noteAutoTick(result, meta = {}) {
   if (!n || !result) return Promise.resolve();
   // A dead login with nowhere to go is named too, so its notice can say whose.
   const named = result.switched || result.reason === "login-expired";
-  return (named ? storeAccounts() : Promise.resolve(null))
-    .then(accounts => n.tick(result, accounts, meta))
+  return (named ? Promise.all([storeAccounts(), result.switched ? telemetryReader() : null]) : Promise.resolve([null, null]))
+    .then(([accounts, telemetryOf]) => n.tick(result, accounts, { ...meta, telemetryOf }))
     .catch(() => {});
 }
 
+/** What each organization's settings were last seen to turn on, as the
+ *  sentence a swap notice carries (org-telemetry.mjs), or null. */
+async function telemetryReader() {
+  try {
+    const { knownOrgTelemetry, telemetryClause } = await import(pathToFileURL(join(PKG_ROOT, "src/server/org-telemetry.mjs")).href);
+    const records = await knownOrgTelemetry();
+    return org => telemetryClause(records?.[org]);
+  } catch {
+    return null;
+  }
+}
+
 /** The loop's way to be asked for a tick now. Called once, as it loads. */
 export function connectEarlyTick(fn) {
   _tickSoon = typeof fn === "function" ? fn : null;
@@ -199,6 +224,35 @@ export function watchOnce(providers) {
   return _watching;
 }
 
+/**
+ * One look at whether the account this deck is on is one a paired deck says it
+ * is on too, handed to the notifier, which says it once per incident.
+ *
+ * The store is read only when some deck is on some account, and through the
+ * roster's own cache, which the panel and every LAN round already keep warm. A
+ * roster that could not be read says nothing and closes nothing: not knowing
+ * which account this deck is on is not the same as being on none.
+ */
+export async function watchElsewhereOnce(now = Date.now()) {
+  const n = notifier();
+  if (!n) return;
+  try {
+    const on = elsewhereNow(now);
+    if (on.size === 0) return n.elsewhere(null, []);
+    const { fetchClaudeAccounts } = await import(pathToFileURL(join(PKG_ROOT, "src/server/claude-accounts.mjs")).href);
+    const got = await fetchClaudeAccounts();
+    if (!got?.ok || !Array.isArray(got.accounts)) return;
+    const live = got.accounts.find(a => a?.active === true);
+    if (!live?.email) return n.elsewhere(null, []);
+    const key = accountKey(live.email, live.orgUuid);
+    const name = typeof live.alias === "string" && live.alias.trim() ? live.alias.trim() : live.email;
+    return n.elsewhere({ key, name }, on.get(key) ?? []);
+  } catch {
+    // The roster's own failures are its panel's to say; here there is nothing
+    // to compare this time.
+  }
+}
+
 /**
  * Start reading quota on a timer, from startServer once the port is bound —
  * never at import, because a launcher imports the server module only to ask
@@ -210,4 +264,9 @@ export function startAccountWatch({ providers } = {}) {
   _timer.unref?.();
   const first = setTimeout(() => { watchOnce(providers).catch(() => {}); }, 15_000);
   first.unref?.();
+  // And Local network's word on the account this deck is on, on its own clock:
+  // it costs nothing while no deck is on anything, and it is said whichever of
+  // the quota switches is on.
+  _elsewhereTimer = setInterval(() => { watchElsewhereOnce().catch(() => {}); }, ELSEWHERE_WATCH_MS);
+  _elsewhereTimer.unref?.();
 }

package/src/server/claude-accounts.mjs

@@ -52,6 +52,10 @@ import { nextReadAt, nudgeCollector } from "./claude-collector.mjs";
 // (#1893). Pure, and keyed the way LAN sync keys accounts.
 import { hasRecovered, reauthFor } from "./account-origins.mjs";
 import { accountKey } from "./lan-copies.mjs";
+// What each organization's Claude settings were last seen to turn on, so a row
+// can say it before anyone switches to the account. See its header for when the
+// shared remote-settings.json can be pinned on an organization at all.
+import { observeOrgTelemetry } from "./org-telemetry.mjs";
 // Whether a switch target's stored login is known dead, and whether a
 // collection would read it first (#2184). Pure, and imports nothing.
 import { collectionWouldRead, deadLoginOf } from "./login-guard.mjs";
@@ -467,6 +471,7 @@ async function readRoster(now, gen) {
   }
 
   const rows = await readUsageRows(root);
+  const orgTelemetry = await observeOrgTelemetry({ seq }).catch(() => ({}));
 
   // Kick a collection for the NEXT poll if anything is due — either because
   // claude-swap's schedule says so, or because an account has never been
@@ -500,7 +505,7 @@ async function readRoster(now, gen) {
     const row = rows[num];
     const key = accountKey(acct.email, acct.organizationUuid);
     const origin = Object.hasOwn(origins, key) ? origins[key] : null;
-    const shown = rosterRow({ seq, num, acct, row, identity, now, key, origin });
+    const shown = rosterRow({ seq, num, acct, row, identity, now, key, origin, telemetry: orgTelemetry[acct.organizationUuid] ?? null });
     accounts.push(shown);
     // A put-off incident is over once a read succeeds after it, and the
     // put-off goes with it (#1893) — said here, where the read is, rather than
@@ -527,7 +532,7 @@ function observedMs(seconds) {
   return Number.isFinite(ms) && ms > 0 && Number.isFinite(new Date(ms).getTime()) ? ms : null;
 }
 
-function rosterRow({ seq, num, acct, row, identity, now, key, origin = null }) {
+function rosterRow({ seq, num, acct, row, identity, now, key, origin = null, telemetry = null }) {
   const matches = rowIsFor(row, acct);
   const good = matches ? row.lastGood : null;
 
@@ -617,6 +622,11 @@ function rosterRow({ seq, num, acct, row, identity, now, key, origin = null }) {
     // claude-swap has refused its login since: `{ key, since, dismissed }`.
     // `key` and `since` together name it, for "Not now" to send back.
     reauth: reauth ? { key, ...reauth } : null,
+    // What this account's organization last turned on for Claude Code's
+    // telemetry export, when the deck has seen its settings (org-telemetry.mjs):
+    // `{ orgName, level, content, destinations, seenAt }`. `level` "off" was
+    // seen off; null was never seen, which is unknown and not "off".
+    telemetry: telemetry ?? null,
   };
 }
 

package/src/server/deck-prefs.mjs

@@ -88,6 +88,10 @@ export const DEFAULTS = Object.freeze({
   // incident (account-notify.mjs). ON for the swap's reason: it is rare, every
   // running session is stopped when it happens, and nothing else says so.
   notifyStopped: true,
+  // A login this deck is on, live on another deck too (#2192). ON, like the
+  // swap: it is rare, it is said once per incident, and nothing else on the
+  // desktop says it before one of the two machines is signed out.
+  notifyElsewhere: true,
   // Continue a BACKGROUND session whose turn stopped on an expired login or a
   // usage limit, once a working login with room is active again — once per
   // stop (stop-continue.mjs, #2193). OFF: it stops and restarts a session's
@@ -344,6 +348,7 @@ export function normalise(raw) {
     notifyQuota: flagOr(src.notifyQuota, DEFAULTS.notifyQuota),
     notifyReset: flagOr(src.notifyReset, DEFAULTS.notifyReset),
     notifyStopped: flagOr(src.notifyStopped, DEFAULTS.notifyStopped),
+    notifyElsewhere: flagOr(src.notifyElsewhere, DEFAULTS.notifyElsewhere),
     continueStopped: flagOr(src.continueStopped, DEFAULTS.continueStopped),
     tourSeen: flagOr(src.tourSeen, DEFAULTS.tourSeen),
     autoUpdate: flagOr(src.autoUpdate, DEFAULTS.autoUpdate),
@@ -729,7 +734,10 @@ export function publicPrefs(prefs) {
  * here — prefs-route-fields.test.ts lists them.
  */
 export const PAGE_FIELDS = Object.freeze({
-  top: Object.freeze(["notifications", "notifySwap", "notifyQuota", "notifyReset", "notifyStopped", "continueStopped", "tourSeen", "autoUpdate", "recoverCodexSessions", "recoverClaudeSessions"]),
+  top: Object.freeze([
+    "notifications", "notifySwap", "notifyQuota", "notifyReset", "notifyStopped", "notifyElsewhere", "continueStopped",
+    "tourSeen", "autoUpdate", "recoverCodexSessions", "recoverClaudeSessions",
+  ]),
   lan: Object.freeze([
     "enabled", "name", "shared", "manual", "shareActive", "sendInUse", "pairingMode",
     "autoAsk", "autoAccept", "tailscale", "tailscaleAsk", "tailscaleAccept",
@@ -763,15 +771,17 @@ export function notificationsOn(prefs, env = process.env) {
 }
 
 /**
- * Which account notifications may go out right now: the four switches, each
- * on its own, and all four off when the machine vetoed notifications at
+ * Which account notifications may go out right now: the five switches, each
+ * on its own, and all five off when the machine vetoed notifications at
  * launch — AGENTS_DECK_NO_NOTIFY=1 keeps the deck off the desktop whatever
  * else it was told, and these are desktop notifications too.
  */
 export function accountNotifySettings(prefs, env = process.env) {
-  if (notificationsVetoed(env)) return { swap: false, quota: false, reset: false, stopped: false };
+  if (notificationsVetoed(env)) return { swap: false, quota: false, reset: false, stopped: false, elsewhere: false };
   const p = normalise(prefs);
-  return { swap: p.notifySwap, quota: p.notifyQuota, reset: p.notifyReset, stopped: p.notifyStopped };
+  return {
+    swap: p.notifySwap, quota: p.notifyQuota, reset: p.notifyReset, stopped: p.notifyStopped, elsewhere: p.notifyElsewhere,
+  };
 }
 
 /**

package/src/server/feature-use.mjs

@@ -23,10 +23,20 @@ const ROUTE_FEATURES = new Map([
   ["POST /api/clear", "clear-board"],
 ]);
 
+/** Features a whole namespace of routes is: a connected tracker's reads carry
+ *  the connection's id in the path (#2178), so they are matched by prefix. The
+ *  name is the provider's, never the connection, board or issue read. */
+const ROUTE_PREFIX_FEATURES = [
+  ["GET /api/integrations/jira/", "jira"],
+  ["GET /api/integrations/github/", "github"],
+  ["GET /api/integrations/gitlab/", "gitlab"],
+];
+
 /** Note the feature a request is, if it is one. Called for requests that got
  *  past the deck's own gates. */
 export function noteRouteFeature(method, pathname) {
-  const name = ROUTE_FEATURES.get(`${method} ${pathname}`);
+  const route = `${method} ${pathname}`;
+  const name = ROUTE_FEATURES.get(route) ?? ROUTE_PREFIX_FEATURES.find(([prefix]) => route.startsWith(prefix))?.[1];
   if (name) usageDay.noteFeature(name);
 }