sideby 0.0.0-stage → 0.2.1

package/dist/src/desktop/icon.js

@@ -0,0 +1,174 @@
+// The sideby mark drawn without dependencies: the Panel header's logo (a dark rounded tile with a light disc
+// split into two halves, offset along the diagonal, the second at 55% opacity) rasterised with analytic
+// antialiasing and encoded as PNG, SVG or ICNS.
+import { deflateSync } from 'node:zlib';
+/** Text stored in every generated file, so `sideby app uninstall` deletes only what it wrote. */
+export const APP_MARKER = 'sideby-app-install';
+// Geometry in the Panel's 40-unit logo box (page.ts: .logo 40×40, radius 10; halves of radius 10.5 centred at
+// 18.5,18.5 facing left and 21.5,21.5 facing right, so they sit 3 apart and mirror through the centre).
+const TILE = { size: 40, radius: 10, color: [0x15, 0x17, 0x1c] };
+const MARK = { color: [0xf5, 0xf6, 0xf8], opacities: [1, 0.55] };
+const HALVES = [
+    { cx: 18.5, cy: 18.5, r: 10.5, side: -1 },
+    { cx: 21.5, cy: 21.5, r: 10.5, side: 1 },
+];
+// The tile sits on the macOS icon grid: 824 of 1024 units, centred.
+const GRID = { canvas: 1024, tile: 824 };
+function shapes(size) {
+    const tilePx = (size * GRID.tile) / GRID.canvas;
+    const off = (size - tilePx) / 2;
+    const u = tilePx / TILE.size;
+    return {
+        tile: { x: off, y: off, w: tilePx, h: tilePx, r: TILE.radius * u },
+        halves: HALVES.map((h) => ({ cx: off + h.cx * u, cy: off + h.cy * u, r: h.r * u, side: h.side })),
+    };
+}
+/** Signed distance from (px, py) to a rounded rectangle; negative inside. */
+function roundedRectDistance(px, py, s) {
+    const hx = s.w / 2;
+    const hy = s.h / 2;
+    const qx = Math.abs(px - (s.x + hx)) - (hx - s.r);
+    const qy = Math.abs(py - (s.y + hy)) - (hy - s.r);
+    const outside = Math.hypot(Math.max(qx, 0), Math.max(qy, 0));
+    return outside + Math.min(Math.max(qx, qy), 0) - s.r;
+}
+/** Signed distance from (px, py) to a half disc: the disc intersected with the half-plane on its side. */
+function halfDistance(px, py, h) {
+    return Math.max(Math.hypot(px - h.cx, py - h.cy) - h.r, (px - h.cx) * -h.side);
+}
+/** RGBA pixels (straight alpha) of the icon at `size`×`size`. */
+export function renderIcon(size) {
+    const { tile, halves } = shapes(size);
+    const layers = [
+        { dist: (x, y) => roundedRectDistance(x, y, tile), color: TILE.color, opacity: 1 },
+        ...halves.map((h, i) => ({
+            dist: (x, y) => halfDistance(x, y, h),
+            color: MARK.color,
+            opacity: MARK.opacities[i],
+        })),
+    ];
+    const px = new Uint8Array(size * size * 4);
+    for (let y = 0; y < size; y++)
+        for (let x = 0; x < size; x++) {
+            // Premultiplied "over" compositing; coverage from the distance at the pixel centre.
+            let r = 0;
+            let g = 0;
+            let b = 0;
+            let a = 0;
+            for (const l of layers) {
+                const cover = Math.min(1, Math.max(0, 0.5 - l.dist(x + 0.5, y + 0.5)));
+                const la = cover * l.opacity;
+                if (la === 0)
+                    continue;
+                r = (l.color[0] / 255) * la + r * (1 - la);
+                g = (l.color[1] / 255) * la + g * (1 - la);
+                b = (l.color[2] / 255) * la + b * (1 - la);
+                a = la + a * (1 - la);
+            }
+            const i = (y * size + x) * 4;
+            if (a > 0) {
+                px[i] = Math.round((r / a) * 255);
+                px[i + 1] = Math.round((g / a) * 255);
+                px[i + 2] = Math.round((b / a) * 255);
+                px[i + 3] = Math.round(a * 255);
+            }
+        }
+    return px;
+}
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(buf) {
+    let c = 0xffffffff;
+    for (const byte of buf)
+        c = CRC_TABLE[(c ^ byte) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const head = Buffer.alloc(8);
+    head.writeUInt32BE(data.length, 0);
+    head.write(type, 4, 'latin1');
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), data])), 0);
+    return Buffer.concat([head, data, crc]);
+}
+/** Encodes straight-alpha RGBA pixels as a PNG with a `Software` text chunk holding APP_MARKER. */
+export function encodePng(width, height, rgba) {
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr.set([8, 6, 0, 0, 0], 8); // 8-bit RGBA, no interlace
+    const raw = Buffer.alloc((width * 4 + 1) * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * (width * 4 + 1)] = 0; // filter: none
+        raw.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * (width * 4 + 1) + 1);
+    }
+    return Buffer.concat([
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        chunk('IHDR', ihdr),
+        chunk('tEXt', Buffer.from(`Software\0${APP_MARKER}`, 'latin1')),
+        chunk('IDAT', deflateSync(raw, { level: 9 })),
+        chunk('IEND', Buffer.alloc(0)),
+    ]);
+}
+export const iconPng = (size) => encodePng(size, size, renderIcon(size));
+/** The macOS `.iconset` file names and their pixel sizes, 16 to 1024. */
+export const ICONSET = [16, 32, 128, 256, 512].flatMap((s) => [
+    { name: `icon_${s}x${s}.png`, size: s },
+    { name: `icon_${s}x${s}@2x.png`, size: s * 2 },
+]);
+// ICNS element types for PNG data, by pixel size (`@2x` variants have their own types).
+const ICNS_TYPES = {
+    'icon_16x16.png': 'icp4',
+    'icon_16x16@2x.png': 'ic11',
+    'icon_32x32.png': 'icp5',
+    'icon_32x32@2x.png': 'ic12',
+    'icon_128x128.png': 'ic07',
+    'icon_128x128@2x.png': 'ic13',
+    'icon_256x256.png': 'ic08',
+    'icon_256x256@2x.png': 'ic14',
+    'icon_512x512.png': 'ic09',
+    'icon_512x512@2x.png': 'ic10',
+};
+/** Builds an `.icns` file directly from PNGs; used when `iconutil` is not available. */
+export function encodeIcns(pngs) {
+    const parts = [];
+    for (const { name } of ICONSET) {
+        const data = pngs.get(name);
+        if (!data)
+            continue;
+        const head = Buffer.alloc(8);
+        head.write(ICNS_TYPES[name], 0, 'latin1');
+        head.writeUInt32BE(data.length + 8, 4);
+        parts.push(head, data);
+    }
+    const body = Buffer.concat(parts);
+    const head = Buffer.alloc(8);
+    head.write('icns', 0, 'latin1');
+    head.writeUInt32BE(body.length + 8, 4);
+    return Buffer.concat([head, body]);
+}
+/** The same mark as an SVG (1024-unit canvas), for Linux icon themes. */
+export function iconSvg() {
+    const { tile, halves } = shapes(GRID.canvas);
+    const hex = (c) => `#${c.map((v) => v.toString(16).padStart(2, '0')).join('')}`;
+    const opacityAttr = (opacity) => (opacity === 1 ? '' : ` fill-opacity="${opacity}"`);
+    const rect = (s, fill) => `  <rect x="${s.x}" y="${s.y}" width="${s.w}" height="${s.h}" rx="${s.r}" fill="${fill}"/>`;
+    // From the top of the cut to its bottom, bulging to the half's side.
+    const half = (h, fill, opacity) => `  <path d="M${h.cx} ${h.cy - h.r}A${h.r} ${h.r} 0 0 ${h.side > 0 ? 1 : 0} ${h.cx} ${h.cy + h.r}Z" fill="${fill}"${opacityAttr(opacity)}/>`;
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${GRID.canvas} ${GRID.canvas}" width="${GRID.canvas}" height="${GRID.canvas}">`,
+        `  <!-- ${APP_MARKER} -->`,
+        rect(tile, hex(TILE.color)),
+        ...halves.map((h, i) => half(h, hex(MARK.color), MARK.opacities[i])),
+        '</svg>',
+        '',
+    ].join('\n');
+}

package/dist/src/families/claude/index.d.ts

@@ -0,0 +1,10 @@
+import type { Account, FamilyDef, Plugin } from '../../types.ts';
+/** The Main Account keeps `.claude.json` in HOME; other Accounts keep it inside their directory. */
+export declare function claudeJsonOf(account: Account): string;
+/**
+ * `oauthAccount.emailAddress` and `organizationName` from `.claude.json`; nothing else is kept. The organization a
+ * personal sign-in gets by default ("<name>'s Organization") says nothing new, so it is left out.
+ */
+export declare function claudeIdentity(account: Account): Promise<import("../../types.ts").AccountIdentity | undefined>;
+export declare const claudeFamily: FamilyDef;
+export declare const claudePlugin: Plugin;

package/dist/src/families/claude/index.js

@@ -0,0 +1,127 @@
+// Built-in Family Plugin for Claude Code (spec §3.4, checked against Claude Code 2.1.289).
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { identityFromJsonFile, identityOf } from '../../core/identity.js';
+import { readSecretFile } from '../../core/secret-file.js';
+import { claudeStatusline } from '../../quota/claude-statusline.js';
+import { BUILTIN_LOGOS } from '../logos.js';
+import { groupedEntryWrittenAt, resumeFlagSession } from '../shared/sessions.js';
+import { CLAUDE_LAYOUT } from './layout.js';
+import { readClaudeQuota } from './quota.js';
+import { readClaudeUsage } from './usage.js';
+const LINKED = [
+    'settings.json',
+    'settings.local.json',
+    'skills',
+    'commands',
+    'plugins',
+    'hooks',
+    'themes',
+    'CLAUDE.md',
+];
+/** The Main Account keeps `.claude.json` in HOME; other Accounts keep it inside their directory. */
+export function claudeJsonOf(account) {
+    return account.isMain ? join(dirname(account.dir), '.claude.json') : join(account.dir, '.claude.json');
+}
+/** Only checks whether `oauthAccount` is present; the parsed content is dropped immediately. */
+async function loginState(account) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(claudeJsonOf(account), 'utf8'));
+    }
+    catch {
+        return 'unknown';
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return 'unknown';
+    return parsed.oauthAccount != null ? 'logged-in' : 'logged-out';
+}
+/**
+ * `oauthAccount.emailAddress` and `organizationName` from `.claude.json`; nothing else is kept. The organization a
+ * personal sign-in gets by default ("<name>'s Organization") says nothing new, so it is left out.
+ */
+export function claudeIdentity(account) {
+    return identityFromJsonFile(claudeJsonOf(account), (data) => {
+        const o = data
+            ?.oauthAccount;
+        if (typeof o !== 'object' || o === null)
+            return undefined;
+        const org = typeof o.organizationName === 'string' && !/'s Organization$/.test(o.organizationName)
+            ? o.organizationName
+            : undefined;
+        return identityOf(o.emailAddress, org);
+    });
+}
+async function model(account) {
+    if (account.kind === 'api') {
+        if (!account.secretFile)
+            return undefined;
+        try {
+            return (await readSecretFile(account.secretFile)).ANTHROPIC_MODEL || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    try {
+        const s = JSON.parse(await readFile(join(account.dir, 'settings.json'), 'utf8'));
+        return typeof s?.model === 'string' && s.model ? s.model : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const claudeFamily = {
+    id: 'claude',
+    title: 'Claude Code',
+    logo: BUILTIN_LOGOS.claude,
+    bin: 'claude',
+    installUrl: 'https://code.claude.com/docs/en/setup',
+    selectVar: 'CLAUDE_CONFIG_DIR',
+    layout: CLAUDE_LAYOUT,
+    // `plugins` alone is too generic: claude-code-router keeps `~/.claude-code-router/plugins`.
+    markers: [
+        '.claude.json',
+        'settings.json',
+        'settings.local.json',
+        'skills',
+        'commands',
+        'hooks',
+        'themes',
+        'CLAUDE.md',
+        'projects',
+    ],
+    hijackVars: [
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_BASE_URL',
+        'ANTHROPIC_MODEL',
+        'ANTHROPIC_SMALL_FAST_MODEL',
+        'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+        'ANTHROPIC_DEFAULT_SONNET_MODEL',
+        'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    ],
+    apiVars: ['ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_MODEL'],
+    sharedItems: [
+        ...LINKED.map((path) => ({ path, mode: 'link' })),
+        { path: '.claude.json', mode: 'json-key', key: 'mcpServers', mainPath: '.claude.json', credential: true },
+    ],
+    login: {
+        args: ['auth', 'login'],
+        hint: 'Opens the browser to sign this account in to Claude (`claude auth login`).',
+    },
+    loginState,
+    model,
+    identity: claudeIdentity,
+    readQuota: readClaudeQuota,
+    readUsage: readClaudeUsage,
+    quotaSetup: claudeStatusline,
+    resumedSession: resumeFlagSession,
+    sessionWrittenAt: (account, id) => groupedEntryWrittenAt(join(account.dir, 'projects'), `${id}.jsonl`, 'file'),
+};
+export const claudePlugin = {
+    name: 'claude',
+    register(api) {
+        api.family(claudeFamily);
+    },
+};

package/dist/src/families/claude/layout.d.ts

@@ -0,0 +1,6 @@
+export declare const CLAUDE_MAIN_DIR = ".claude";
+export declare const CLAUDE_ACCOUNT_PREFIX = ".claude-";
+export declare const CLAUDE_LAYOUT: {
+    main: string;
+    account: string;
+};

package/dist/src/families/claude/layout.js

@@ -0,0 +1,5 @@
+// Where Claude Code keeps an Account. A leaf module (no imports) shared by the Family, the quota setup and
+// the status line tap, which must not import the Family's index on every refresh.
+export const CLAUDE_MAIN_DIR = '.claude';
+export const CLAUDE_ACCOUNT_PREFIX = '.claude-';
+export const CLAUDE_LAYOUT = { main: CLAUDE_MAIN_DIR, account: `${CLAUDE_ACCOUNT_PREFIX}<name>` };

package/dist/src/families/claude/quota-cache.d.ts

@@ -0,0 +1,31 @@
+import type { Env, QuotaWindow } from '../../types.ts';
+export interface ClaudeQuotaCache {
+    version: 1;
+    /** When the status line last reported these windows. */
+    observedAt: string;
+    windows: QuotaWindow[];
+}
+export declare function claudeQuotaCacheFile(stateDir: string, name: string): string;
+/** sideby's state directory for this environment (same rule as the Runtime). */
+export declare function cacheStateDir(env: Env): string;
+/** Account name from CLAUDE_CONFIG_DIR: unset or `~/.claude` is `main`, `.claude-<name>` is `<name>`, else null. */
+export declare function accountNameFromEnv(env: Env): string | null;
+/** Extracts the 5h and 7d windows from status line JSON; null when there is nothing usable. */
+export declare function parseRateLimits(input: string, observedAt: Date): ClaudeQuotaCache | null;
+/** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
+export declare function writeQuotaCache(stateDir: string, name: string, cache: ClaudeQuotaCache): Promise<void>;
+export type CacheRead = {
+    status: 'ok';
+    observedAt: string;
+    windows: QuotaWindow[];
+} | {
+    status: 'missing';
+} | {
+    status: 'unrecognized';
+    detail: string;
+};
+/**
+ * Reads the cache. Accepts any file with a parseable `observedAt` and at least one valid window; `version`
+ * is not enforced so caches written by earlier releases keep working.
+ */
+export declare function readQuotaCache(stateDir: string, name: string): Promise<CacheRead>;

package/dist/src/families/claude/quota-cache.js

@@ -0,0 +1,111 @@
+// The Claude Quota cache: one module owns where it lives, how the Account is named, and how it is written,
+// read and validated. The status line tap writes it on every refresh, so this module imports only leaf
+// modules and Node built-ins (never the Family index, the Runtime or core/accounts.ts).
+import { mkdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { ACCOUNT_NAME } from '../../core/account-name.js';
+import { writeFileAtomic } from '../../core/fs-safe.js';
+import { resolvePaths } from '../../core/paths.js';
+import { CLAUDE_ACCOUNT_PREFIX, CLAUDE_MAIN_DIR } from './layout.js';
+const WINDOWS = [
+    { key: 'five_hour', label: '5h', minutes: 300 },
+    { key: 'seven_day', label: '7d', minutes: 10_080 },
+];
+export function claudeQuotaCacheFile(stateDir, name) {
+    return join(stateDir, 'quota', 'claude', `${name}.json`);
+}
+/** sideby's state directory for this environment (same rule as the Runtime). */
+export function cacheStateDir(env) {
+    return resolvePaths(env).stateDir;
+}
+/** Account name from CLAUDE_CONFIG_DIR: unset or `~/.claude` is `main`, `.claude-<name>` is `<name>`, else null. */
+export function accountNameFromEnv(env) {
+    const dir = env.CLAUDE_CONFIG_DIR;
+    if (!dir)
+        return 'main';
+    if (resolve(dir) === join(env.HOME || homedir(), CLAUDE_MAIN_DIR))
+        return 'main';
+    const base = basename(dir);
+    if (!base.startsWith(CLAUDE_ACCOUNT_PREFIX))
+        return null;
+    const name = base.slice(CLAUDE_ACCOUNT_PREFIX.length);
+    return name !== 'main' && ACCOUNT_NAME.test(name) ? name : null;
+}
+/** Extracts the 5h and 7d windows from status line JSON; null when there is nothing usable. */
+export function parseRateLimits(input, observedAt) {
+    let data;
+    try {
+        data = JSON.parse(input);
+    }
+    catch {
+        return null;
+    }
+    const rl = data?.rate_limits;
+    if (typeof rl !== 'object' || rl === null)
+        return null;
+    const windows = [];
+    for (const w of WINDOWS) {
+        const v = rl[w.key];
+        if (typeof v !== 'object' || v === null)
+            continue;
+        const used = v.used_percentage;
+        const resets = v.resets_at;
+        if (typeof used !== 'number' || !Number.isFinite(used))
+            continue;
+        if (typeof resets !== 'number' || !Number.isFinite(resets) || resets <= 0)
+            continue;
+        windows.push({
+            label: w.label,
+            windowMinutes: w.minutes,
+            usedPercent: used,
+            resetsAt: new Date(resets * 1000).toISOString(),
+        });
+    }
+    return windows.length ? { version: 1, observedAt: observedAt.toISOString(), windows } : null;
+}
+/** Writes the cache atomically; creates the private parent directory first (writeFileAtomic does not). */
+export async function writeQuotaCache(stateDir, name, cache) {
+    const file = claudeQuotaCacheFile(stateDir, name);
+    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
+    await writeFileAtomic(file, `${JSON.stringify(cache)}\n`, 0o600);
+}
+function validWindow(w) {
+    if (typeof w !== 'object' || w === null)
+        return false;
+    const v = w;
+    return (typeof v.label === 'string' &&
+        typeof v.windowMinutes === 'number' &&
+        typeof v.usedPercent === 'number' &&
+        typeof v.resetsAt === 'string' &&
+        Number.isFinite(Date.parse(v.resetsAt)));
+}
+/**
+ * Reads the cache. Accepts any file with a parseable `observedAt` and at least one valid window; `version`
+ * is not enforced so caches written by earlier releases keep working.
+ */
+export async function readQuotaCache(stateDir, name) {
+    const file = claudeQuotaCacheFile(stateDir, name);
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { status: 'missing' };
+        throw err;
+    }
+    let cache;
+    try {
+        cache = JSON.parse(raw);
+    }
+    catch {
+        return { status: 'unrecognized', detail: `${file} is not valid JSON` };
+    }
+    const windows = Array.isArray(cache?.windows) ? cache.windows.filter(validWindow) : [];
+    if (typeof cache?.observedAt !== 'string' ||
+        !Number.isFinite(Date.parse(cache.observedAt)) ||
+        !windows.length)
+        return { status: 'unrecognized', detail: `${file} has no usable quota windows` };
+    return { status: 'ok', observedAt: cache.observedAt, windows };
+}

package/dist/src/families/claude/quota.d.ts

@@ -0,0 +1,3 @@
+import type { Account, QuotaResult, ReadContext } from '../../types.ts';
+export declare const QUOTA_SOURCE = "claude statusline";
+export declare function readClaudeQuota(account: Account, ctx: ReadContext): Promise<QuotaResult>;

package/dist/src/families/claude/quota.js

@@ -0,0 +1,53 @@
+// Quota for a Claude subscription Account: the windows `sideby statusline-tap` last cached for it.
+// Windows past `resetsAt` are returned unchanged; callers compare with the current time and show "reset".
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { realpathOrNull } from '../../core/fs-safe.js';
+import { claudeStatusline, isWrapped, mainSettingsFile } from '../../quota/claude-statusline.js';
+import { readQuotaCache } from './quota-cache.js';
+export const QUOTA_SOURCE = 'claude statusline';
+/** How the Account reaches the wrapper: the shared main settings.json, its own wrapped file, or neither. */
+async function accountWrapped(account, ctx) {
+    if (account.isMain)
+        return 'shared';
+    const own = join(account.dir, 'settings.json');
+    const [a, b] = await Promise.all([realpathOrNull(own), realpathOrNull(mainSettingsFile(ctx.home))]);
+    if (a !== null && a === b)
+        return 'shared';
+    try {
+        const s = JSON.parse(await readFile(own, 'utf8'));
+        return isWrapped(s?.statusLine?.command) ? 'own' : 'own-unwrapped';
+    }
+    catch {
+        return 'own-unwrapped';
+    }
+}
+async function withoutCache(account, ctx) {
+    const wiring = await accountWrapped(account, ctx);
+    if (wiring === 'own-unwrapped')
+        return {
+            status: 'unavailable',
+            reason: 'not-enabled',
+            detail: "this account's settings.json is not shared with the main account, so its quota needs its own status line setup",
+        };
+    const planStatus = await claudeStatusline.plan(ctx).then((p) => p.status, () => 'blocked');
+    if (wiring === 'shared' && planStatus !== 'enabled')
+        return {
+            status: 'unavailable',
+            reason: 'not-enabled',
+            detail: 'run `sideby quota setup claude` to record Claude quota from the status line',
+        };
+    return {
+        status: 'unavailable',
+        reason: 'no-session',
+        detail: 'start a Claude Code session with this account; quota is recorded after its first reply',
+    };
+}
+export async function readClaudeQuota(account, ctx) {
+    const read = await readQuotaCache(ctx.stateDir, account.name);
+    if (read.status === 'missing')
+        return withoutCache(account, ctx);
+    if (read.status === 'unrecognized')
+        return { status: 'unavailable', reason: 'unrecognized', detail: read.detail };
+    return { status: 'ok', windows: read.windows, observedAt: read.observedAt, source: QUOTA_SOURCE };
+}

package/dist/src/families/claude/usage.d.ts

@@ -0,0 +1,22 @@
+import { FileMemo } from '../../core/file-memo.ts';
+import type { Account, ReadContext, UsageResult } from '../../types.ts';
+interface Entry {
+    timestamp: number;
+    session: string;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+/** What one session log holds: its usage rows in file order, keyed for the "last line wins" dedupe. */
+interface Parsed {
+    lines: number;
+    parsed: number;
+    rows: [string, Entry][];
+    /** The read stopped early; the rows so far still count, but the result is not remembered. */
+    failed: boolean;
+}
+/** Parsed session logs per Account directory; a file is parsed again only after it changed. */
+export declare const claudeUsageMemo: FileMemo<Parsed>;
+export declare function readClaudeUsage(account: Account, ctx: ReadContext): Promise<UsageResult>;
+export {};