sideby 0.13.0 → 0.14.0

package/dist/src/panel/i18n.js

@@ -21,7 +21,10 @@ const en = {
     'upd.runs': 'Updating runs:',
     'upd.after': 'A background panel restarts by itself and this page reloads. A sideby ui running in a terminal and sessions already running keep the old version until you restart them.',
     'upd.cannot': 'sideby cannot update itself here: {why}. Run this yourself:',
-    'upd.skill': 'If you use the sideby skill, update it too:',
+    'upd.skill': 'If you use the sideby skill, install it with:',
+    'upd.skillToo': 'The sideby skill agents read is updated with it.',
+    'upd.skillDone': 'The sideby skill was updated too; agents load it in their next session.',
+    'upd.skillManaged': 'sideby leaves the skill alone ({why}). Update it with:',
     'upd.checksOff': 'Update checks are off ({why}).',
     'upd.latest': 'This is the newest version',
     'upd.latestNow': 'You have the newest version (checked just now).',
@@ -140,6 +143,26 @@ const en = {
     'sort.pressure': 'Sort: quota used',
     'sort.name': 'Sort: name',
     'sort.recent': 'Sort: last used',
+    'sort.manual': 'Sort: my order',
+    'order.handle': 'Drag to move, or use the arrow keys',
+    'order.moveFamily': 'Move {name}',
+    'order.moveAccount': 'Move {name}',
+    'order.position': '{name}: place {n} of {total}',
+    'order.failed': 'Could not save the order: {msg}. It is back as it was.',
+    'order.resetButton': 'Default order',
+    'order.resetHint': 'Forget the order you dragged tools and accounts into',
+    'order.reset': 'Back to the default order',
+    'quota.fetchFailed': 'Could not get the quota',
+    'quota.checkOff': 'Quota check off',
+    'quota.checkOffHint': 'Turn it on in Settings to see this quota.',
+    'quota.fetchedFrom': '{host} asked for this quota {ago}',
+    'quota.lastCheckFailed': 'The latest check failed: {why}',
+    'quota.refreshFailed': 'Could not ask for the newest quota: {msg}',
+    'quota.checkOnToast': '{host} quota check is on',
+    'quota.checkOffToast': '{host} quota check is off',
+    'quota.checkFailed': 'Could not change the setting: {msg}',
+    'set.quotaCheck': '{host} quota',
+    'set.quotaCheckHint': "{host} asks for each account's quota, at most every {n} minutes. sideby never reads its login.",
     'tb.quota': 'Show quota as',
     'tb.used': 'Used',
     'tb.left': 'Left',
@@ -198,13 +221,10 @@ const en = {
     'quota.dataFrom': 'Data from {ago}',
     'quota.asOf': 'As of {ago}',
     'quota.sharedFrom': 'Same login as {name}; quota read from {name}, {ago}',
-    'quota.readFrom': 'Quota read from {name}, {ago}',
-    'login.count': '{n} directories share one quota',
     'login.label': 'Same login: {names}',
+    'login.shared': "Shares {name}'s quota",
+    'login.sharedHint': "Signed in as the same login as {name}: the vendor counts one quota for both, shown on {name}'s row.",
     'login.hint': '{names} are signed in as the same login. The vendor counts one quota for all of them, so it shows once here, and a handoff never moves between them.',
-    'login.sharedAbove': 'Uses the quota above',
-    'login.collapse': 'Hide {names}',
-    'login.expand': 'Show {names}',
     'quota.noWindows': 'No quota windows reported.',
     'quota.off': 'Quota not on',
     'quota.turnOnFamily': 'Turn on quota',
@@ -630,7 +650,10 @@ const zh = {
     'upd.runs': '更新会运行：',
     'upd.after': '后台面板会自己重启，本页随后自动刷新。终端里运行的 sideby ui 和已经在跑的会话要重启后才用新版本。',
     'upd.cannot': '这种安装方式下 sideby 不能自己更新：{why}。请自己运行：',
-    'upd.skill': '如果你装了 sideby skill，也更新一下：',
+    'upd.skill': '如果要用 sideby skill，用这条命令安装：',
+    'upd.skillToo': 'agent 读的 sideby skill 会一起更新。',
+    'upd.skillDone': 'sideby skill 也已更新，agent 下次开会话时生效。',
+    'upd.skillManaged': 'sideby 不会自动更新这个 skill（{why}）。请用这条命令更新：',
     'upd.checksOff': '检查更新已关闭（{why}）。',
     'upd.latest': '已是最新版本',
     'upd.latestNow': '已是最新版本（刚刚检查）。',
@@ -749,6 +772,26 @@ const zh = {
     'sort.pressure': '排序：额度用量',
     'sort.name': '排序：名称',
     'sort.recent': '排序：最近使用',
+    'sort.manual': '排序：我的顺序',
+    'order.handle': '拖动换位置，或用方向键',
+    'order.moveFamily': '移动 {name}',
+    'order.moveAccount': '移动 {name}',
+    'order.position': '{name}：第 {n} 个，共 {total} 个',
+    'order.failed': '顺序没有保存：{msg}。已恢复原来的顺序。',
+    'order.resetButton': '默认顺序',
+    'order.resetHint': '忘掉你拖出来的工具和账号顺序',
+    'order.reset': '已恢复默认顺序',
+    'quota.fetchFailed': '没拿到额度',
+    'quota.checkOff': '额度查询已关',
+    'quota.checkOffHint': '在「设置」里打开，就能看到这份额度。',
+    'quota.fetchedFrom': '{host} {ago}查询的额度',
+    'quota.lastCheckFailed': '最近一次查询失败：{why}',
+    'quota.refreshFailed': '没能查询最新额度：{msg}',
+    'quota.checkOnToast': '已打开 {host} 额度查询',
+    'quota.checkOffToast': '已关闭 {host} 额度查询',
+    'quota.checkFailed': '设置没有改成：{msg}',
+    'set.quotaCheck': '{host} 额度',
+    'set.quotaCheckHint': '{host} 自己查询每个账号的额度，最多每 {n} 分钟一次。sideby 不读它的登录信息。',
     'tb.quota': '额度显示方式',
     'tb.used': '已用',
     'tb.left': '剩余',
@@ -807,13 +850,10 @@ const zh = {
     'quota.dataFrom': '数据来自 {ago}',
     'quota.asOf': '截至 {ago}',
     'quota.sharedFrom': '与 {name} 同一登录；额度读自 {name}，{ago}',
-    'quota.readFrom': '额度读自 {name}，{ago}',
-    'login.count': '{n} 个目录共用一份额度',
     'login.label': '同一登录：{names}',
+    'login.shared': '与 {name} 共用额度',
+    'login.sharedHint': '与 {name} 用同一个身份登录，供应商只算一份额度，显示在 {name} 那一行。',
     'login.hint': '{names} 用同一个身份登录。供应商只算一份额度，所以这里只显示一次，交接也不会在它们之间进行。',
-    'login.sharedAbove': '共用上方的额度',
-    'login.collapse': '收起 {names}',
-    'login.expand': '展开 {names}',
     'quota.noWindows': '没有额度窗口数据。',
     'quota.off': '额度未开启',
     'quota.turnOnFamily': '开启额度显示',

package/dist/src/panel/page-logic.d.ts

@@ -20,6 +20,7 @@ export interface LogicAccount {
         status: string;
         windows?: {
             label: string;
+            name?: string;
             windowMinutes: number;
             usedPercent: number;
             resetsAt: string;
@@ -88,8 +89,23 @@ export declare function attentionWhy(a: LogicAccount, health: {
     key: string;
     vars: Record<string, string | number>;
 } | null;
-/** Sorted copy: `pressure` (fullest Quota first), `name`, or `recent` (last activity first). The Main Account leads ties. */
-export declare function sortAccounts<T extends LogicAccount>(list: T[], mode: string, now: number): T[];
+/**
+ * `items` in Display Order (spec §3.25): those whose key is in `order` first, in that order; the others after, in the
+ * order they came. Names no longer there are simply not met.
+ */
+export declare function inDisplayOrder<T>(items: readonly T[], key: (t: T) => string, order?: readonly string[]): T[];
+/**
+ * The Display Order after a drag (spec §3.25). `all` is every key of the list in the current Display Order, hidden
+ * ones included; `shown` is what the screen showed, in its order, as units (one key, or a Same Login group that moves
+ * as one). The unit at `from` moves to `to`; the shown keys then fill the places shown keys held in `all`, so keys a
+ * filter hides keep their place among themselves.
+ */
+export declare function reorder(all: readonly string[], shown: readonly (readonly string[])[], from: number, to: number): string[];
+/**
+ * Sorted copy: `pressure` (fullest Quota first), `name`, `recent` (last activity first), or `manual` (the Family's
+ * Display Order `order`, names not in it after). The Main Account leads ties.
+ */
+export declare function sortAccounts<T extends LogicAccount>(list: T[], mode: string, now: number, order?: readonly string[]): T[];
 /**
  * The sorted list with each Same Login together (spec §3.21): an Account, or the shown members of one login, in
  * order, at the place of its first member. A login with one shown member stays a plain Account.

package/dist/src/panel/page-logic.js

@@ -44,14 +44,16 @@ export function quotaPressure(a, now) {
     const q = a.quota;
     if (q?.status !== 'ok' || !q.windows)
         return -1;
+    // A named window covers only some models and never counts (spec §3.26).
+    const windows = q.windows.filter((w) => !w.name);
     let max = -1;
-    for (const w of q.windows) {
+    for (const w of windows) {
         const reset = Date.parse(w.resetsAt);
         if (Number.isFinite(reset) && reset <= now)
             continue;
         max = Math.max(max, Math.max(0, Math.min(100, Number(w.usedPercent) || 0)));
     }
-    return q.windows.length && max < 0 ? 0 : max;
+    return windows.length && max < 0 ? 0 : max;
 }
 /**
  * Why an Account needs a look, most serious first: `error`, `health-fail`, `signed-out`, `not-installed`,
@@ -71,6 +73,8 @@ export function attentionReasons(a, health, now, warn) {
     const q = a.quota;
     if (q && q.status === 'ok' && q.windows && !q.from)
         for (const w of q.windows) {
+            if (w.name)
+                continue;
             const reset = Date.parse(w.resetsAt);
             if (Number.isFinite(reset) && reset <= now)
                 continue;
@@ -96,6 +100,8 @@ export function attentionWhy(a, health, now, warn) {
         return { key: `why.${reason}`, vars: {} };
     let top = null;
     for (const w of a.quota?.windows ?? []) {
+        if (w.name)
+            continue;
         const reset = Date.parse(w.resetsAt);
         if (Number.isFinite(reset) && reset <= now)
             continue;
@@ -105,16 +111,55 @@ export function attentionWhy(a, health, now, warn) {
     }
     return { key: 'why.quota-high', vars: { label: top?.label ?? '', pct: Math.round(top?.pct ?? 0), warn } };
 }
-/** Sorted copy: `pressure` (fullest Quota first), `name`, or `recent` (last activity first). The Main Account leads ties. */
-export function sortAccounts(list, mode, now) {
+/**
+ * `items` in Display Order (spec §3.25): those whose key is in `order` first, in that order; the others after, in the
+ * order they came. Names no longer there are simply not met.
+ */
+export function inDisplayOrder(items, key, order) {
+    const at = new Map((order ?? []).map((k, i) => [k, i]));
+    return items
+        .map((t, i) => ({ t, i, r: at.has(key(t)) ? at.get(key(t)) : (order?.length ?? 0) }))
+        .sort((x, y) => x.r - y.r || x.i - y.i)
+        .map((x) => x.t);
+}
+/**
+ * The Display Order after a drag (spec §3.25). `all` is every key of the list in the current Display Order, hidden
+ * ones included; `shown` is what the screen showed, in its order, as units (one key, or a Same Login group that moves
+ * as one). The unit at `from` moves to `to`; the shown keys then fill the places shown keys held in `all`, so keys a
+ * filter hides keep their place among themselves.
+ */
+export function reorder(all, shown, from, to) {
+    const units = shown.slice();
+    if (from < 0 || from >= units.length || to < 0 || to >= units.length)
+        return all.slice();
+    const [unit] = units.splice(from, 1);
+    units.splice(to, 0, unit);
+    const next = units.flat();
+    const visible = new Set(next);
+    const out = all.slice();
+    for (const k of next)
+        if (!out.includes(k))
+            out.push(k);
+    let i = 0;
+    for (let at = 0; at < out.length; at++)
+        if (visible.has(out[at]))
+            out[at] = next[i++];
+    return out;
+}
+/**
+ * Sorted copy: `pressure` (fullest Quota first), `name`, `recent` (last activity first), or `manual` (the Family's
+ * Display Order `order`, names not in it after). The Main Account leads ties.
+ */
+export function sortAccounts(list, mode, now, order) {
     const byName = (x, y) => Number(Boolean(y.isMain)) - Number(Boolean(x.isMain)) ||
         x.name.localeCompare(y.name, undefined, { numeric: true });
     const pressure = (a) => {
         const q = a.quota;
         if (q?.status !== 'ok' || !q.windows)
             return -1;
-        let max = q.windows.length ? 0 : -1;
-        for (const w of q.windows) {
+        const windows = q.windows.filter((w) => !w.name);
+        let max = windows.length ? 0 : -1;
+        for (const w of windows) {
             const reset = Date.parse(w.resetsAt);
             if (!(Number.isFinite(reset) && reset <= now))
                 max = Math.max(max, Number(w.usedPercent) || 0);
@@ -128,6 +173,8 @@ export function sortAccounts(list, mode, now) {
     const out = list.slice();
     if (mode === 'name')
         out.sort(byName);
+    else if (mode === 'manual')
+        return inDisplayOrder(out.sort(byName), (a) => a.name, order);
     else if (mode === 'recent')
         out.sort((x, y) => last(y) - last(x) || byName(x, y));
     else