dsh-mobile-plugin 0.5.28 → 0.5.29

package/extensions/magpie/autobackup.js

@@ -0,0 +1,185 @@
+// Settings › Sync's Back up by itself (jwaitq on Discord: 定期自动备份，
+// 支持回退选择版本): the setup backed up into a folder on this computer on a
+// schedule, the last few kept, and any of them put back, what is here being
+// backed up first so that can be undone. app.js imports this when Settings
+// draws Sync, so it weighs nothing on the core.
+
+// the server's view, kept over Settings' redraws and read again when it is
+// half a minute old; the read under way, which a redraw while it is out
+// draws with too; what the last restore came to, said once under the
+// versions
+let autoBackupView = null;
+let autoBackupAt = 0;
+let autoBackupLoad = null;
+let autoBackupSaid = null;
+// the passphrase asked for as the sign-ins are turned on, when none is set
+let autoBackupPhrase = false;
+
+// autoBackupFill puts the rows in place of at, the empty element renderSync
+// leaves at the end of Sync's list: rows, so the list's lines run between
+// them as between Sync's own.
+window.autoBackupFill = function (at) {
+  let drawn = [at];
+  const draw = () => {
+    if (!drawn[0].isConnected) return;
+    const rows = autoBackupRows(autoBackupView);
+    drawn[0].before(...rows);
+    for (const r of drawn) r.remove();
+    drawn = rows;
+  };
+  if (autoBackupView) draw();
+  if (Date.now() - autoBackupAt >= 30000) {
+    autoBackupAt = Date.now();
+    const load = api("autobackup").then((v) => { autoBackupView = v; }, (e) => { autoBackupView = { error: e.message, backups: [] }; });
+    autoBackupLoad = load;
+    load.then(() => { if (autoBackupLoad === load) autoBackupLoad = null; });
+  }
+  autoBackupLoad?.then(draw);
+};
+
+// autoBackupDo posts one action and draws Sync again with what it says
+async function autoBackupDo(action, body, b) {
+  b?.classList.add("busy");
+  try {
+    autoBackupView = await api("autobackup/" + action, body || {});
+    autoBackupAt = Date.now();
+  } catch (e) {
+    statusErr(e);
+  }
+  renderSync();
+}
+
+function autoBackupRows(v) {
+  const rows = [];
+  const row = (name, sub, ...tools) => {
+    const r = el("div", "row pref auto-backup");
+    const who = el("div", "who");
+    const s = el("div", "sub", sub);
+    who.append(el("div", "name", name), s);
+    const val = el("div", "val");
+    val.append(...tools);
+    r.append(who, val);
+    rows.push(r);
+    return r;
+  };
+  const btn = (label, fn) => { const b = el("button", "text", label); b.type = "button"; b.onclick = (e) => fn(b, e); return b; };
+  const on = !!v.on;
+  const head = row(t("Back up by itself"), v.error ? t("Couldn't back up: {error}", { error: v.error })
+    : on ? (v.signIns ? t("Your providers, settings and profiles, without API keys, and the sign-ins sealed with a passphrase, into a folder on this computer")
+      : t("Your providers, settings and profiles, without API keys or sign-ins, into a folder on this computer")) : t("Off: no backups are made by themselves"),
+  segs([[0, t("Off")], [1, t("1 hour")], [6, t("6 hours")], [24, t("1 day")], [168, t("1 week")]], on ? v.hours : 0,
+    (h) => autoBackupDo("set", h ? { on: true, hours: h } : { on: false })));
+  if (v.error) head.querySelector(".sub").classList.add("bad", "wraps");
+  if (on) {
+    row(t("Versions kept"), t("The oldest is removed when a new one is made; one is made only when something changed"),
+      segs([3, 7, 14, 30].map((n) => [n, String(n)]), v.keep, (n) => autoBackupDo("set", { keep: n })));
+    // the sign-ins (qianxunji, curtinp118 on Discord): off unless picked,
+    // and sealed with a passphrase asked for the first time
+    const asking = autoBackupPhrase && !v.signIns;
+    row(t("Sign-ins in backups"), v.signIns ? t("Subscription accounts and plugin sign-ins, sealed with the passphrase set here")
+      : t("Off: after a restore on another computer, sign in again"),
+    segs([["off", t("Off")], ["on", t("On")]], v.signIns || asking ? "on" : "off", (x) => {
+      if (x === "on" && !v.passphrase) { autoBackupPhrase = true; renderSync(); return; }
+      autoBackupPhrase = false;
+      autoBackupDo("set", { signIns: x === "on" });
+    }));
+    if (asking) rows.push(autoBackupPhraseForm());
+  }
+  if (on || v.backups?.length) {
+    const tools = [btn(t("Change…"), (b) => autoBackupDo("choose", {}, b)), btn(t("Show"), () => api("autobackup/reveal", {}).catch(statusErr))];
+    if (v.custom) tools.push(btn(t("Default"), (b) => autoBackupDo("set", { dir: "" }, b)));
+    const dir = row(t("Backup folder"), v.dir || "", ...tools).querySelector(".sub");
+    dir.classList.add("wraps", "auto-backup-dir");
+    // in magpie's own folder, the default: a reinstalled system takes the
+    // backups with it (two_2025. on Discord, magpie on C:)
+    if (v.inside) dir.after(el("div", "sub wraps auto-backup-inside", t("In magpie's own folder: a reinstalled system or a lost disk takes these backups too. Pick a folder on another disk, or one a cloud drive syncs")));
+  }
+  const list = v.backups || [];
+  const sub = row(t("Versions"), list.length ? t("{n} backups · newest {when}", { n: list.length, when: syncWhen(list[0].made) }) : t("None yet"),
+    btn(t("Back up now"), (b) => autoBackupDo("now", {}, b))).querySelector(".sub");
+  if (autoBackupSaid) {
+    sub.after(...autoBackupSaid.map((l) => el("div", "sub wraps auto-backup-said", l)));
+    autoBackupSaid = null;
+  }
+  for (const b of list) {
+    const when = autoBackupWhen(b.made);
+    const what = [t(b.providers === 1 ? "1 provider" : "{n} providers", { n: b.providers })];
+    if (b.reason === "restore") what.unshift(t("What was here before a restore"));
+    if (b.signIns) what.push(t("sign-ins"));
+    row(when, what.join(" · "), btn(t("Restore…"), () => autoBackupAsk(b, when))).classList.add("auto-backup-version");
+  }
+  return rows;
+}
+
+// autoBackupWhen names a version by when it was made, as its row does
+const autoBackupWhen = (made) => new Date(made).toLocaleString(intlLang(), { year: "numeric", month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+
+// autoBackupAsk asks before a version is put back, in the app's own
+// dialog, saying what changes and that what is here is backed up first.
+function autoBackupAsk(b, when) {
+  const ed = el("div", "editor restore-ask auto-backup-ask");
+  const head = el("div", "ehead");
+  head.append(el("b", "", t("Restore the backup of {when}?", { when })));
+  ed.append(head);
+  ed.append(el("p", "lib-confirm", t("Your providers, settings, profiles and agents' models become this backup's. Providers added since are kept, and each keeps its API keys here.")));
+  if (b.signIns) ed.append(el("p", "lib-confirm", t("Its sign-ins are put in where they were renewed later than the ones here; none here is removed.")));
+  ed.append(el("p", "lib-confirm", t("What is here now is backed up first: restore that one to undo this.")));
+  const err = el("p", "editor-error", "");
+  ed.append(err);
+  const bar = el("div", "bar");
+  const go = el("button", "text primary danger-fill", t("Restore"));
+  go.onclick = async (e) => {
+    e.stopPropagation();
+    go.disabled = true;
+    go.classList.add("busy");
+    try {
+      const r = await api("autobackup/restore", { name: b.name });
+      closeConfirmAsk();
+      autoBackupView = r.view;
+      autoBackupAt = Date.now();
+      const x = r.result || {};
+      const lines = [t("Restored the backup of {when}", { when }) + " · " + t("Providers: {added} added, {replaced} replaced; {profiles} profiles; {agents} agent settings changed", { added: x.Added, replaced: x.Replaced, profiles: x.Profiles, agents: x.Agents })];
+      if (x.NeedKey?.length) lines.push(t("Needs a key: {names}", { names: x.NeedKey.join(", ") }));
+      if (x.SignIns) { await import("./syncfiles.js"); lines.push(...signInsSaid(x.SignIns)); }
+      if (x.SignInsLocked) lines.push(t("This backup's sign-ins are sealed with another passphrase, so they were left out."));
+      const before = r.view?.backups?.find((k) => k.name === r.before);
+      if (before) lines.push(t("What was here before is the version of {when}: restore it to undo.", { when: autoBackupWhen(before.made) }));
+      autoBackupSaid = lines;
+      renderSync();
+      refreshAfterSync();
+    } catch (x) {
+      go.disabled = false;
+      go.classList.remove("busy");
+      err.textContent = x.message;
+    }
+  };
+  const cancel = el("button", "text", t("Cancel"));
+  cancel.onclick = cancelAsk;
+  bar.append(el("span", "grow"), cancel, go);
+  ed.append(bar);
+  confirmAsk = ed;
+  openModal(ed);
+  $("#modal").classList.add("lib");
+  cancel.focus(NO_SCROLL);
+}
+
+// autoBackupPhraseForm asks for the passphrase the backups' sign-ins are
+// sealed with, as they are turned on
+function autoBackupPhraseForm() {
+  const ed = el("div", "editor sync-form auto-backup-phrase");
+  const p1 = input("", t("passphrase"), "password");
+  const p2 = input("", t("again"), "password");
+  ed.append(...field(t("Passphrase"), p1, t("The sign-ins in each backup are sealed with it. Anyone with a backup and the passphrase can use those accounts. Keep it: without it a backup's sign-ins can't be opened.")),
+    ...field("", p2));
+  const go = el("button", "text primary", t("Turn on"));
+  const cancel = el("button", "text", t("Cancel"));
+  const say = syncBar(ed, "", el("span", "grow"), cancel, go);
+  cancel.onclick = () => { autoBackupPhrase = false; renderSync(); };
+  go.onclick = async () => {
+    if (!p1.value) return say(t("Pick a passphrase: the file is sealed with it"));
+    if (p1.value !== p2.value) return say(t("The two passphrases differ"));
+    autoBackupPhrase = false;
+    await autoBackupDo("set", { signIns: true, passphrase: p1.value }, go);
+  };
+  return ed;
+}

package/extensions/magpie/autoresetown.js

@@ -0,0 +1,151 @@
+// Settings › Usage's Codex auto-use rows: each ChatGPT account's switches
+// and, under them, how early a reset about to expire is used. app.js
+// imports this when Settings draws them (renderAutoResetOwn), so it weighs
+// nothing on the core.
+
+// renderAutoResetOwn lists each ChatGPT account under Settings › Usage's
+// "Codex: auto-use resets", with its switch, the same say as on the
+// account's card (settings' codexAutoReset, the CLI's quota auto-reset).
+// Avalon on Discord: it was only on the accounts' cards, not in the
+// window's Settings. The row shows while a Codex
+// account is signed in, or one is still on.
+window.autoResetOwnPaint = function (s) {
+  const head = $("#codexAutoResetRow");
+  const list = head.parentElement;
+  list.querySelectorAll(".ar-own").forEach((r) => r.remove());
+  const on = s.codexAutoReset || [];
+  const users = [...(s.codexUsers || [])];
+  for (const u of on) if (!users.some((x) => x.toLowerCase() === u)) users.push(u);
+  head.hidden = !users.length;
+  // each account's resets, read as the providers' editor reads them,
+  // with Use beside them (husky_bobo on X looked for it here)
+  const held = users.length ? loginUsageOf("codex") : null;
+  if (users.length && !held) loginUsage.codex?.loading?.then(() => { if (!head.hidden && loginUsage.codex?.data) autoResetOwnPaint(prefs || s); });
+  let after = head;
+  for (const user of users) {
+    const r = el("div", "row pref ar-own");
+    r.dataset.user = user;
+    const who = el("div", "who");
+    const name = el("div", "name", user);
+    name.title = user;
+    who.append(name);
+    const q = held && Object.entries(held).find(([u]) => u.toLowerCase() === user.toLowerCase())?.[1];
+    if (q?.resets?.count && !q.error && !q.resets.byWindow) {
+      const qu = { ...q, provider: "codex", user };
+      const sub = el("div", "sub ar-own-resets");
+      const use = el("button", "text", t("Use a reset"));
+      use.title = resetUseTitle(qu);
+      use.setAttribute("aria-haspopup", "dialog");
+      use.onclick = (e) => { e.stopPropagation(); askReset(qu); };
+      sub.append(resetsWords(qu.resets, qu), " ", use);
+      who.append(sub);
+    }
+    // each of the two times its own Off/On (#2078)
+    const was = on.includes(user.toLowerCase()) ? autoResetWhenOf(s.codexAutoResetOnly?.[user.toLowerCase()]) : { week: false, expiring: false };
+    const cases = el("div", "ar-own-cases");
+    for (const c of AUTO_RESET_CASES) {
+      const line = el("div", "ar-own-case");
+      line.dataset.case = c.id;
+      const say = el("span", "ar-own-say", t(c.say));
+      say.title = t(was[c.id] ? c.on : c.off, resetLeadVars());
+      const pick = segs([["off", t("Off")], ["on", t("On")]], was[c.id] ? "on" : "off", async (v) => {
+        try {
+          prefs = await writingPrefs(api("settings/codex-auto-reset", { user, on: v === "on", when: c.id }));
+          if (state) state.settings = prefs;
+          const now = (prefs.codexAutoReset || []).includes(user.toLowerCase()) ? autoResetWhenOf(prefs.codexAutoResetOnly?.[user.toLowerCase()]) : { week: false, expiring: false };
+          status(autoResetStatus(user, now), "ok");
+          renderSettings();
+          if (quotas) renderQuotas(); // the account's card says the same
+        } catch (e) {
+          statusTErr(e);
+          renderSettings();
+        }
+      });
+      pick.setAttribute("aria-label", t("Auto-use resets") + " · " + t(c.say) + " · " + user);
+      line.append(say, pick);
+      cases.append(line);
+    }
+    r.append(who, cases);
+    after.after(r);
+    after = r;
+  }
+  renderResetLead(s, head.hidden);
+};
+
+// renderResetLead: how long before a reset about to run out unused it is
+// used, under the accounts' switches, one for them all; a pick from the
+// app's menu (settings/codex-reset-lead). A value set outside the choices
+// (Custom…, or the CLI) is shown and kept (shangyuan0818 on Discord).
+function renderResetLead(s, hidden) {
+  const row = $("#codexResetLeadRow");
+  if (!row) return;
+  row.hidden = hidden;
+  // a redraw leaves Custom…'s field being typed in
+  const own = $("#codexResetLeadPick .reset-lead-own");
+  if (own && !own.dataset.done) return;
+  const cur = resetLeadMinutes(s);
+  const leads = RESET_LEADS.includes(cur) ? RESET_LEADS : [...RESET_LEADS, cur].sort((a, b) => a - b);
+  const name = (m) => t("{lead} before", { lead: resetLeadWords(m) });
+  const b = el("button", "sess-pick reset-lead");
+  b.type = "button";
+  b.setAttribute("aria-haspopup", "menu");
+  b.setAttribute("aria-label", t("Codex: how early before one expires") + ": " + name(cur));
+  // every choice in one cell, the current one seen: the button is as wide
+  // as the widest, so a pick doesn't rewrap the row and move the page
+  const say = el("span", "rl-say");
+  for (const m of leads) {
+    const w = el("span", m === cur ? "on" : "", name(m));
+    if (m !== cur) w.setAttribute("aria-hidden", "true");
+    say.append(w);
+  }
+  b.append(say, svg(CHEV, 11, 1.6));
+  b.onclick = (e) => {
+    e.stopPropagation();
+    if (b.classList.contains("open")) return closeProtoMenu();
+    const opts = leads.map((m) => ({ v: String(m), name: name(m), note: m === 30 ? "Default" : "", literalName: true }));
+    openProtoMenu(b, [...opts, { v: "\x01", name: "Custom…" }], String(cur), (v) => v === "\x01" ? resetLeadOwn(b, cur, set) : set(Number(v)), "Used before it expires", "sess-menu", "right");
+  };
+  const set = async (m) => {
+    if (m === cur) return renderSettings();
+    try {
+      prefs = await writingPrefs(api("settings/codex-reset-lead", { minutes: m }));
+      if (state) state.settings = prefs;
+      renderSettings();
+      if (quotas) renderQuotas(); // the cards' titles say it too
+    } catch (err) {
+      statusTErr(err);
+      renderSettings();
+    }
+  };
+  $("#codexResetLeadPick").replaceChildren(b);
+}
+
+// resetLeadOwn: Custom…'s field of minutes in the button's place; Enter or
+// leaving saves, Escape doesn't, one out of range is said, not written.
+function resetLeadOwn(b, cur, set) {
+  const least = RESET_LEADS[0], most = RESET_LEADS.at(-1);
+  const i = input(String(cur), least + "–" + most);
+  i.className = "words compact-num reset-lead-own";
+  i.inputMode = "numeric";
+  i.setAttribute("aria-label", t("Minutes"));
+  let done = false;
+  const finish = (save) => {
+    if (done) return;
+    done = true;
+    i.dataset.done = "1";
+    const v = i.value.trim(), m = /^\d+$/.test(v) ? Number(v) : NaN;
+    if (!save || !v) return renderSettings();
+    if (!(m >= least && m <= most)) {
+      status(t("Minutes is a whole number from 3 to 1440"), "err");
+      return renderSettings();
+    }
+    set(m);
+  };
+  i.onkeydown = (e) => { e.stopPropagation(); if (e.key === "Enter") finish(true); else if (e.key === "Escape") finish(false); };
+  i.onblur = () => finish(true);
+  // in the button's box: the row doesn't rewrap and move the page
+  i.style.width = b.offsetWidth + "px";
+  i.style.height = b.offsetHeight + "px";
+  b.replaceWith(i);
+  i.focus(NO_SCROLL);
+}

package/extensions/magpie/balfound.js

@@ -0,0 +1,38 @@
+// A relay added by hand with no Balance URL has its balance found by
+// magpie where relays tell a key it (provider/balance_probe.go). Under the
+// Balance URL the editor says where, with Use to copy it into the fields,
+// so an amount read at the wrong query can be put right. app.js imports
+// this when the editor draws a relay's balance with no Balance URL.
+let balFoundAt = null;
+window.balFound = function (box, p, draft, bal, pathOf) {
+  const line = el("div", "bal-found");
+  line.hidden = true;
+  balFoundAt = { line, draft, bal, pathOf };
+  box.append(line);
+  bal.addEventListener("input", () => { line.hidden = !line.dataset.url || !!bal.value.trim(); });
+  window.balFoundShow({ found: p.balanceFound, foundField: p.balanceFoundField });
+};
+// what the editor's Check balance found (app.js), drawn again
+window.balFoundShow = function (r) {
+  const s = balFoundAt;
+  if (!s || !s.line.isConnected) return;
+  const { line, draft, bal, pathOf } = s;
+  line.replaceChildren();
+  line.dataset.url = r.found || "";
+  line.hidden = !r.found || !!(draft.balanceURL || "").trim();
+  if (!r.found) return;
+  const txt = el("span", "", t("Found by magpie: {url}", { url: r.found + (r.foundField ? " " + r.foundField : "") }));
+  txt.title = t("magpie asked this relay where relays tell a key its balance, and reads it here. If the amount is wrong, put in your own Balance URL and field; magpie looks again each day");
+  const use = el("button", "text action", t("Use"));
+  use.type = "button";
+  use.title = t("Put this query in the Balance URL and Balance field, to change it");
+  use.onclick = () => {
+    draft.balanceURL = bal.value = r.found;
+    draft.balancePath = r.foundField || "";
+    const f = pathOf();
+    if (f) { f.value = draft.balancePath; f.placeholder = balanceFieldOf(r.found); }
+    line.hidden = true;
+    bal.focus();
+  };
+  line.append(txt, use);
+};

package/extensions/magpie/boot.js

@@ -0,0 +1,23 @@
+// magpie 网页版启动时由 Go 侧动态生成的那一段（原产在 internal/gui/api.go 的 `GET /boot.js`）。
+//
+// 上游仓库里没有这个文件：它是宿主在运行时拼出来的，内容是**页面开始绘制之前**要拿到的那
+// 几项（语言、主题、字号、是不是网页版、这个版本号，以及内置插件被关掉的那几张页）。
+// 我们这套是本地跑的原版前端，宿主换成我们自己，所以按同样的形状在这里静态给一份 ——
+// 少了它，`bootPrefs` 是 undefined，页面会按英文与浅色画第一帧，之后设置回来了再跳一次。
+//
+// 形状必须与上游一致（`window.bootPrefs = {...}` 一行）。想改哪一项就改下面这张表，
+// 别再往页面里塞第二份。
+window.bootPrefs = {
+  // 页面语言。上游取的是用户在 magpie 里存的那门；这里给中文，与两边界面一致。
+  lang: 'zh',
+  // 'light' / 'dark' / '' 跟随系统
+  theme: '',
+  // 100 = 正常大小；上游是用户在设置里调的那个百分比
+  textSize: 100,
+  // true = 这一页由 `magpie web` 端出来（没有 App 窗口那一层）。原版前端靠它决定
+  // 「链接自己开、属于桌面的那几张页不画」，我们正是这个形态。
+  web: true,
+  // 端出这一页的那个 magpie 的版本。前端用它判断「是不是换了一个进程在答」。
+  // 真值由本地代理盖掉（见 scripts/serve.mjs），这里是兜底。
+  version: '',
+};

package/extensions/magpie/cfgblocked.js

@@ -0,0 +1,39 @@
+// The Repair dialog for a folder on the way to magpie's own that isn't the
+// user's, most often a ~/.config a command run with sudo made root's
+// (YouWhat on Discord: adding a provider said "mkdir ~/.config/magpie:
+// permission denied"). app.js imports this only when /api/state names such
+// a folder or a save fails for it (configBlockedAsk), so it weighs nothing
+// on the core. Repair makes the folder the user's again, after the system's
+// password prompt; asked once a load, and again over whatever save failed,
+// which "Not now" goes back to as it was left.
+window.cfgBlockedAsk = function (path) {
+  if (confirmAsk?.classList.contains("cfg-blocked")) return;
+  configBlockedAsked = true;
+  const m = $("#modal"), under = !m.hidden && !m.classList.contains("out") && !confirmAsk && m.firstElementChild.firstElementChild;
+  const ed = el("div", "editor cfg-blocked"), head = el("div", "ehead"), bar = el("div", "bar");
+  head.append(el("b", "", t("magpie can't save its settings")));
+  ed.append(head, el("p", "lib-confirm", t("{path} belongs to another user, often after a command was run with sudo, so magpie can't save providers or settings there. Repair makes it yours again; the system may ask for your password.", { path })));
+  const later = el("button", "text", t("Not now")), go = el("button", "text primary", t("Repair"));
+  later.onclick = cancelAsk;
+  go.onclick = async (e) => {
+    e.stopPropagation();
+    go.disabled = true;
+    try {
+      if ((await api("config/repair", {}))?.canceled) return;
+      if (state) state.configBlocked = "";
+      closeConfirmAsk();
+      status(t("Repaired: magpie can save again"), "ok");
+    } catch (err) {
+      status(err.message, "err", 12000);
+    } finally {
+      go.disabled = false;
+    }
+  };
+  bar.append(el("span", "grow"), later, go);
+  ed.append(bar);
+  if (under) ed.back = () => openModal(under); // the editor whose save failed, as it was left
+  confirmAsk = ed;
+  openModal(ed);
+  m.classList.add("lib");
+  go.focus({ preventScroll: true });
+};

package/extensions/magpie/checkinnow.js

@@ -0,0 +1,111 @@
+// Settings' Check in now for one account (xiaowu_95660: 手动签到一次):
+// its row, the press and what it came to. app.js imports this when
+// Settings draws a vendor's check-in (checkinNowRow), so it weighs nothing
+// on the core.
+
+// what each vendor's last press said, kept over Settings' redraws
+const checkinNowSaid = {};
+
+// ciNowFill draws Check in now into row, for vendor by's accounts: one
+// account checked in once now, picked from the app menu when there are
+// several, its switch and the account's left as they are; what came of it
+// is said in the row.
+window.ciNowFill = function (row, s, by) {
+  const accts = (s.checkinAccounts || []).filter((a) => (a.by || "") === by);
+  row.dataset.by = by;
+  const sub = el("div", "sub");
+  const who = el("div", "who");
+  who.append(el("div", "name", t("Check in now")), sub);
+  const box = el("div");
+  row.append(who, box);
+  const draw = () => {
+    const said = checkinNowSaid[by];
+    sub.textContent = said ? said.text : t("Checks one account in once now; the daily check-in's switches stay as they are");
+    sub.classList.toggle("err", !!said?.bad);
+    sub.classList.toggle("say", !!said); // what came of it: a state, kept in sight
+    const b = el("button", "text ci-now-go", t(accts.length > 1 ? "Check in…" : "Check in"));
+    b.type = "button";
+    b.disabled = !!said?.busy;
+    b.classList.toggle("busy", !!said?.busy);
+    if (accts.length > 1) b.setAttribute("aria-haspopup", "menu");
+    b.onclick = (e) => {
+      e.stopPropagation();
+      if (accts.length === 1) return send(accts[0]);
+      if (b.classList.contains("open")) return closeProtoMenu();
+      openProtoMenu(b, accts.map((a) => ({ v: a.key, name: a.user || a.key, note: "", literalName: true })), null,
+        (k) => send(accts.find((a) => a.key === k)), "Check in which account", "sess-menu", "right");
+    };
+    box.replaceChildren(b);
+  };
+  const send = (a) => ciNowSend(a, by, (o) => { checkinNowSaid[by] = o; if (row.isConnected) draw(); });
+  draw();
+  row.hidden = false;
+};
+
+// ciAcctFill puts an account's own Check in now in slot, on its row in
+// the provider editor (xwoffice_91592): q is its reading, which carries
+// its check-in (checkinBy, checkinKey). The press is Settings' one,
+// said the same way, and the row's reading is asked again after.
+window.ciAcctFill = function (slot, q, agent, user) {
+  const b = el("button", "text ci-acct", t("Check in now"));
+  b.type = "button";
+  b.title = t("Checks one account in once now; the daily check-in's switches stay as they are");
+  b.onclick = (e) => {
+    e.stopPropagation();
+    ciNowSend({ key: q.checkinKey, user }, q.checkinBy || "", (o) => {
+      b.disabled = !!o.busy;
+      b.classList.toggle("busy", !!o.busy);
+      if (o.busy) return;
+      if (loginUsage[agent]) loginUsage[agent].at = 0;
+      loginUsageOf(agent);
+    });
+  };
+  slot.replaceWith(b);
+};
+
+// ciNowSend checks account a of vendor by in once now and says, through
+// say, how it went; no switch is changed.
+window.ciNowSend = async function (a, by, say) {
+  if (!a) return;
+  const name = a.user || a.key;
+  say({ busy: true, text: t("Checking in {who}…", { who: name }) });
+  try {
+    const r = await api("usage/checkin-account", { by, key: a.key });
+    const said = checkinNowLine(r, name);
+    say(said);
+    status(said.text, said.bad ? "err" : "ok");
+  } catch (err) {
+    const text = t("Couldn't check in {who}: {why}", { who: name, why: t(err.message) });
+    say({ bad: true, text });
+    status(text, "err");
+  }
+  // the Usage cards' lines read again; Settings isn't drawn again under
+  // the button just pressed, which a redraw moved at 420px
+  loadQuotas();
+};
+
+// checkinNowLine is what one account's press came to: checked in now,
+// already in today, not eligible or no event, its own app's, or failed,
+// with the vendor's reason.
+function checkinNowLine(r, who) {
+  const why = r?.msg ? " · " + r.msg : "";
+  switch (r?.outcome) {
+    case "claimed":
+    case "done":
+      if (r.again) return { text: t("{user}: {name} says already checked in; magpie asks again later", { user: who, name: checkinVendorName(r) }) };
+      if (r.outcome === "claimed" && r.asked) return { text: t("Checked in {who}", { who }) + (r.credit ? " +" + r.credit : "") + (r.streak ? " · " + t("{n}-day streak", { n: r.streak }) : "") };
+      return { text: t("{who} was already checked in today", { who }) };
+    case "ineligible":
+      return { text: t("{user} is not eligible", { user: who }) + why };
+    case "inactive":
+      return { text: t("{user}: no check-in event now", { user: who }) + why };
+    case "captcha":
+      return { text: t("{user} is asked for a captcha; check in in the app", { user: who }) };
+    case "own-app":
+      return { text: r.by === "trae"
+        ? t("{user}: Trae CN refused this check-in (9074: too many taking part); check in in the Trae CN app", { user: who })
+        : t("{user}: {name} only gives check-in credits to its own app; check in in the {name} app", { user: who, name: checkinVendorName(r) }) };
+    default:
+      return { bad: true, text: t("Couldn't check in {who}: {why}", { who, why: r?.msg || t("Check-in failed") }) };
+  }
+}

package/extensions/magpie/claudemode.js

@@ -0,0 +1,92 @@
+// The Claude Code provider editor's "Claude Code runs as" row: whether a
+// Claude subscription's runs are Claude Code's interactive mode (TUI) or
+// claude -p, switched right there, how the last request went, and on hover
+// what each is and what it is good for (the owner, 10-31, 11-01). With the
+// interactive mode on a request it can't take fails, saying why (the owner,
+// 11-01); a turn Anthropic refuses there as a third-party app's runs as -p
+// (#4503). app.js imports this with the row's first
+// read of /api/claude/mode (claudeModeRow), so it weighs nothing on the
+// core.
+
+// why the interactive mode can't run here, or is off, by the gateway's
+// code (claudeMachineWhy)
+const CC_WHY = {
+  off: "the interactive mode is off in Settings",
+  os: "this system can't run the interactive mode",
+  missing: "Claude Code isn't installed on this computer",
+};
+const ccWhy = (code) => t(CC_WHY[code] || CC_WHY.os);
+
+// ccTip: the two modes side by side, the one chosen marked
+let ccTipEl = null;
+function ccTip(anchor, tui) {
+  ccTipOff();
+  const tip = ccTipEl = el("div", "cc-tip");
+  tip.setAttribute("role", "tooltip");
+  const mode = (on, name, what, good, bad) => {
+    const m = el("div", "cc-m" + (on ? " on" : ""));
+    const h = el("div", "h");
+    h.append(el("b", "", name));
+    if (on) h.append(el("span", "now", t("In use")));
+    m.append(h, el("p", "", what), el("p", "good", good));
+    if (bad) m.append(el("p", "bad", bad));
+    return m;
+  };
+  tip.append(
+    mode(tui, t("Interactive mode (TUI)"),
+      t("magpie opens Claude Code as a person does, in a terminal of its own that you don't see, types each request in and reads the reply from its transcript."),
+      t("Your plan counts these requests as Claude Code's own use, at about half of the 5-hour allowance that -p uses for the same work.")),
+    mode(!tui, "claude -p",
+      t("Claude Code's print mode, the one scripts and the Agent SDK use: a request in, its reply out."),
+      t("It starts at once, with no terminal of its own to open first."),
+      t("The plan counts a -p request at about twice the interactive mode's.")),
+    el("div", "foot", t("Switched here or in Settings › Models › Replies. With the interactive mode on, a request it can't take, or one it fails to start for, fails saying why. A turn Anthropic refuses there as a third-party app's runs as -p.")));
+  document.body.append(tip);
+  const a = anchor.getBoundingClientRect(), b = tip.getBoundingClientRect();
+  tip.style.left = Math.max(8, Math.min(a.left, innerWidth - b.width - 8)) + "px";
+  tip.style.top = (a.bottom + 8 + b.height < innerHeight - 8 ? a.bottom + 8 : Math.max(8, a.top - b.height - 8)) + "px";
+}
+function ccTipOff() {
+  ccTipEl?.remove();
+  ccTipEl = null;
+}
+
+// claudeModeDraw fills box, the row app.js put in the editor, from m, a
+// read of /api/claude/mode
+window.claudeModeDraw = function (box, m) {
+  if (!m) return;
+  const v = el("div", "cc-run");
+  // on unless turned off, whether or not this machine can run it: on where
+  // it can't, Claude requests fail
+  const on = m.why !== "off";
+  const pick = segs([["tui", t("Interactive mode (TUI)")], ["p", "claude -p"]], on ? "tui" : "p", async (id) => {
+    ccTipOff();
+    if ((id === "tui") === on) return;
+    // the settings are read with the Settings page: one not opened yet has
+    // none to keep
+    if (!prefs) prefs = state.settings = await api("settings");
+    await savePrefs({ ...prefsKeep(prefs), claudePrintMode: id === "p" });
+    claudeMode = await api("claude/mode").catch(() => null);
+    claudeModeAt = Date.now();
+    if (box.isConnected) window.claudeModeDraw(box, claudeMode);
+  });
+  pick.classList.add("cc-pick");
+  pick.classList.toggle("tui", m.tui);
+  // magpie web shows the gateway's, which only its own Settings change
+  for (const b of pick.querySelectorAll(".opt")) b.disabled = gatewayMode;
+  // Chromium has no onfocusin property: the events are listened for
+  pick.onmouseenter = () => ccTip(pick, on);
+  pick.addEventListener("focusin", () => ccTip(pick, on));
+  pick.onmouseleave = () => ccTipOff();
+  pick.addEventListener("focusout", (e) => { if (!pick.contains(e.relatedTarget)) ccTipOff(); });
+  v.append(pick);
+  const last = m.last;
+  let said = "";
+  if (on && !m.tui) said = t("Claude requests fail: {why}", { why: ccWhy(m.why) });
+  else if (!on) said = t("Every request runs as claude -p");
+  else if (last && last.tui) said = t("Last request {ago}: interactive mode", { ago: ago(last.at) });
+  if (said) v.append(el("span", "cc-said" + (on && !m.tui ? " bad" : ""), said));
+  box.replaceChildren(...field(t("Claude Code runs as"), v, ""));
+};
+// the editor going away takes its tip with it
+addEventListener("pointerdown", (e) => { if (!e.target.closest?.(".cc-pick")) ccTipOff(); }, true);