sideby 0.0.0-stage → 0.1.0

package/dist/src/families/codex/rollout.js

@@ -0,0 +1,298 @@
+// Reads Codex Quota and Usage from the Account's local rollout files (spec §3.7, ADR-0003).
+// No network, no credentials: only `token_count` events the Host writes into `sessions/**/rollout-*.jsonl`.
+// Each file's parse is remembered until the file changes (core/file-memo.ts), so a refresh reads only new rollouts.
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { createInterface } from 'node:readline';
+import { FileMemo } from '../../core/file-memo.js';
+import { USAGE_DAYS } from '../../core/quota-levels.js';
+import { dailyBuckets } from '../../core/usage-days.js';
+export const MAX_QUOTA_FILES = 20;
+const ROLLOUT = /^rollout-.*\.jsonl$/;
+const MAX_RESETS_AT_SECONDS = 1e11;
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isNum(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+/** Every rollout file under `<dir>/sessions`, newest mtime first. */
+export async function listRollouts(dir) {
+    const root = join(dir, 'sessions');
+    let entries;
+    try {
+        entries = await readdir(root, { recursive: true, withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const e of entries) {
+        if (!e.isFile() || !ROLLOUT.test(e.name))
+            continue;
+        const path = join(e.parentPath, e.name);
+        try {
+            const st = await stat(path);
+            out.push({ path, mtimeMs: st.mtimeMs, stats: st });
+        }
+        catch {
+            // removed while scanning
+        }
+    }
+    return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+/**
+ * Yields parsed `token_count` payloads with their event time; bad and truncated lines are skipped. A read error
+ * ends the file early and sets `read.failed`, so a caller does not remember a partial parse.
+ */
+async function* tokenCounts(file, read = { failed: false }) {
+    const lines = createInterface({ input: createReadStream(file), crlfDelay: Number.POSITIVE_INFINITY });
+    try {
+        for await (const line of lines) {
+            if (!line.includes('token_count'))
+                continue;
+            let o;
+            try {
+                o = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isObj(o) || !isObj(o.payload) || o.payload.type !== 'token_count')
+                continue;
+            const at = typeof o.timestamp === 'string' ? Date.parse(o.timestamp) : Number.NaN;
+            if (!Number.isFinite(at))
+                continue;
+            yield { at, payload: o.payload };
+        }
+    }
+    catch {
+        // unreadable file: keep what was read
+        read.failed = true;
+    }
+    finally {
+        lines.close();
+    }
+}
+export function windowLabel(minutes) {
+    if (minutes === 300)
+        return '5h';
+    if (minutes === 10080)
+        return '7d';
+    return `${minutes}m`;
+}
+function quotaWindow(raw) {
+    if (!isObj(raw))
+        return null;
+    const { used_percent: used, window_minutes: minutes, resets_at: resets } = raw;
+    if (!isNum(used) || !isNum(minutes) || minutes <= 0)
+        return null;
+    // Seconds since the epoch; a millisecond value would land tens of thousands of years ahead.
+    if (!isNum(resets) || resets <= 0 || resets >= MAX_RESETS_AT_SECONDS)
+        return null;
+    return {
+        label: windowLabel(minutes),
+        windowMinutes: minutes,
+        usedPercent: used,
+        resetsAt: new Date(resets * 1000).toISOString(),
+    };
+}
+function rateLimits(payload) {
+    const rl = payload.rate_limits;
+    if (!isObj(rl))
+        return null;
+    const primary = quotaWindow(rl.primary);
+    if (!primary)
+        return null;
+    const windows = [primary];
+    if (rl.secondary !== null && rl.secondary !== undefined) {
+        const secondary = quotaWindow(rl.secondary);
+        if (!secondary)
+            return null;
+        windows.push(secondary);
+    }
+    return { windows, ...(typeof rl.plan_type === 'string' ? { plan: rl.plan_type } : {}) };
+}
+async function fileLimits(file) {
+    const read = { failed: false };
+    let best = null;
+    for await (const { at, payload } of tokenCounts(file, read)) {
+        if (best && at < best.at)
+            continue;
+        const rl = rateLimits(payload);
+        if (rl)
+            best = { at, ...rl };
+    }
+    return { best, failed: read.failed };
+}
+/** Parsed `rate_limits` per Account directory; a rollout is read again only after it changed. */
+export const codexQuotaMemo = new FileMemo();
+/** Newest well-formed `rate_limits` across the newest rollout files, by event timestamp. */
+export async function readCodexQuota(dir) {
+    const files = (await listRollouts(dir)).slice(0, MAX_QUOTA_FILES);
+    if (files.length === 0)
+        return { status: 'unavailable', reason: 'no-session', detail: 'no Codex session in this account yet' };
+    let best = null;
+    const memo = codexQuotaMemo.pass(dir);
+    for (const f of files) {
+        // Same pick as reading every line in this order: the newest event wins, a later one on a tie.
+        const fb = (await memo.get(f.path, f.stats, () => fileLimits(f.path), (v) => !v.failed)).best;
+        if (fb && (!best || fb.at >= best.at))
+            best = { ...fb, file: f.path };
+    }
+    memo.done();
+    if (!best)
+        return {
+            status: 'unavailable',
+            reason: 'unrecognized',
+            detail: `no rate_limits event in the newest ${files.length} rollout file(s)`,
+        };
+    return {
+        status: 'ok',
+        windows: best.windows,
+        observedAt: new Date(best.at).toISOString(),
+        source: relative(dir, best.file),
+        ...(best.plan ? { plan: best.plan } : {}),
+    };
+}
+function parseTotals(t) {
+    if (!isObj(t) || !isNum(t.input_tokens) || !isNum(t.output_tokens))
+        return null;
+    return {
+        input: t.input_tokens,
+        cached: isNum(t.cached_input_tokens) ? t.cached_input_tokens : 0,
+        output: t.output_tokens,
+        cacheWrite: isNum(t.cache_write_input_tokens) ? t.cache_write_input_tokens : 0,
+    };
+}
+/** Cumulative totals so far in the session, plus this turn's own usage when the event carries it. */
+function totals(payload) {
+    const info = payload.info;
+    if (!isObj(info))
+        return null;
+    const total = parseTotals(info.total_token_usage);
+    return total ? { total, turn: parseTotals(info.last_token_usage) } : null;
+}
+const ZERO = { input: 0, cached: 0, output: 0, cacheWrite: 0 };
+const FIELDS = ['input', 'cached', 'output', 'cacheWrite'];
+const size = (t) => t.input + t.output + t.cacheWrite;
+const plus = (a, b) => ({
+    input: a.input + b.input,
+    cached: a.cached + b.cached,
+    output: a.output + b.output,
+    cacheWrite: a.cacheWrite + b.cacheWrite,
+});
+const minus = (a, b) => ({
+    input: Math.max(0, a.input - b.input),
+    cached: Math.max(0, a.cached - b.cached),
+    output: Math.max(0, a.output - b.output),
+    cacheWrite: Math.max(0, a.cacheWrite - b.cacheWrite),
+});
+/** True when any counter went down: each one only grows within a segment. */
+const dropped = (now, prev) => FIELDS.some((k) => now[k] < prev[k]);
+/**
+ * What each event adds, by index. `total_token_usage` is cumulative per segment: every field, cached input
+ * included, only grows until the Host starts a new segment, where they all start again from zero. A subagent's
+ * file starts from its parent's running total. So the first event adds its total minus the starting baseline
+ * (that total minus the first turn's own usage, zero for an ordinary session), an event where any field went
+ * down starts a new segment and adds its whole total, and any other event adds its growth. Every field of every
+ * increment is therefore zero or more, and any run of events sums to exactly what it added.
+ */
+export function fileDeltas(events) {
+    if (events.length === 0)
+        return [];
+    const first = events[0];
+    const baseline = first.turn ? minus(first.total, first.turn) : ZERO;
+    const out = [minus(first.total, baseline)];
+    let prev = first.total;
+    for (const e of events.slice(1)) {
+        out.push(dropped(e.total, prev) ? minus(e.total, ZERO) : minus(e.total, prev));
+        prev = e.total;
+    }
+    return out;
+}
+/** Tokens one whole rollout file adds: the sum of its fileDeltas. */
+export function fileTokens(events) {
+    if (events.length === 0)
+        return null;
+    return fileDeltas(events).reduce(plus, ZERO);
+}
+async function fileUsage(file) {
+    const read = { failed: false };
+    const times = [];
+    const events = [];
+    for await (const { at, payload } of tokenCounts(file, read)) {
+        times.push(at);
+        const t = totals(payload);
+        if (t)
+            events.push({ at, ...t });
+    }
+    return { times, events, deltas: fileDeltas(events), failed: read.failed };
+}
+/** Parsed token totals per Account directory; a rollout is read again only after it changed. */
+export const codexUsageMemo = new FileMemo();
+/**
+ * Token totals for events in the last `days` x 24 h, from rollout files modified in that window (mtime only
+ * picks which files to read). Each event counts its fileDeltas increment, so a long session resumed today
+ * adds only its recent turns. `daily` spreads the same increments over local days.
+ */
+export async function readCodexUsage(dir, now, days = USAGE_DAYS) {
+    const end = now.getTime();
+    const since = end - days * 24 * 60 * 60 * 1000;
+    const files = (await listRollouts(dir)).filter((f) => f.mtimeMs >= since);
+    if (files.length === 0)
+        return {
+            status: 'unavailable',
+            reason: 'no-session',
+            detail: `no Codex session in the last ${days} days`,
+        };
+    let sessions = 0;
+    let sawTokenCount = false;
+    let sawTotals = false;
+    let last = Number.NEGATIVE_INFINITY;
+    const daily = dailyBuckets(now, days);
+    const sum = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+    const memo = codexUsageMemo.pass(dir);
+    for (const f of files) {
+        const { times, events, deltas } = await memo.get(f.path, f.stats, () => fileUsage(f.path), (v) => !v.failed);
+        if (times.length)
+            sawTokenCount = true;
+        for (const at of times)
+            if (at <= end && at > last)
+                last = at;
+        if (events.length)
+            sawTotals = true;
+        let used = ZERO;
+        let inWindow = false;
+        for (const [i, e] of events.entries()) {
+            if (e.at < since || e.at > end)
+                continue;
+            inWindow = true;
+            used = plus(used, deltas[i]);
+            daily.add(e.at, size(deltas[i]));
+        }
+        if (!inWindow)
+            continue;
+        sessions++;
+        const cached = Math.min(used.cached, used.input);
+        sum.inputTokens += used.input - cached;
+        sum.cacheReadTokens += cached;
+        sum.outputTokens += used.output;
+        sum.cacheWriteTokens += used.cacheWrite;
+    }
+    memo.done();
+    if (sessions === 0)
+        return sawTokenCount && !sawTotals
+            ? { status: 'unavailable', reason: 'unrecognized', detail: 'token_count events have no usable totals' }
+            : { status: 'unavailable', reason: 'no-session', detail: `no Codex turn in the last ${days} days` };
+    return {
+        status: 'ok',
+        days,
+        sessions,
+        ...sum,
+        totalTokens: sum.inputTokens + sum.outputTokens + sum.cacheReadTokens + sum.cacheWriteTokens,
+        daily: daily.daily,
+        ...(Number.isFinite(last) ? { lastActivityAt: new Date(last).toISOString() } : {}),
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { Account, FamilyDef, Plugin } from '../../types.ts';
+/**
+ * The `email` of the single sign-in entry in auth.json (keyed by the auth server, such as `https://auth.x.ai::<id>`).
+ * Only that field is read; tokens and every other field are dropped. Several entries give no answer.
+ */
+export declare function grokIdentity(account: Account): Promise<import("../../types.ts").AccountIdentity | undefined>;
+export declare const grokFamily: FamilyDef;
+export declare const grokPlugin: Plugin;

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

@@ -0,0 +1,78 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { identityFromJsonFile, identityOf } from '../../core/identity.js';
+import { BUILTIN_LOGOS } from '../logos.js';
+import { topLevelTomlString } from '../shared/toml.js';
+// Grok's sandbox rejects these paths when they are symlinks; doctor quotes the Host's own words.
+const HOOKS_DIR_MESSAGE = 'Grok hooks directory has wrong type (expected real directory)';
+const REAL_FILE_MESSAGE = 'Grok hooks-paths registry has wrong type (expected real file)';
+const AUTH_MESSAGE = 'the policy lock file under ~/.grok-00x is not accessible';
+/** `model = "..."` before the first `[table]` of config.toml. */
+async function readModel(account) {
+    let text;
+    try {
+        text = await readFile(join(account.dir, 'config.toml'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    return topLevelTomlString(text, 'model');
+}
+/**
+ * The `email` of the single sign-in entry in auth.json (keyed by the auth server, such as `https://auth.x.ai::<id>`).
+ * Only that field is read; tokens and every other field are dropped. Several entries give no answer.
+ */
+export function grokIdentity(account) {
+    return identityFromJsonFile(join(account.dir, 'auth.json'), (data) => {
+        if (typeof data !== 'object' || data === null || Array.isArray(data))
+            return undefined;
+        const entries = Object.values(data);
+        if (entries.length !== 1)
+            return undefined;
+        const entry = entries[0];
+        return typeof entry === 'object' && entry !== null
+            ? identityOf(entry.email)
+            : undefined;
+    });
+}
+export const grokFamily = {
+    id: 'grok',
+    title: 'Grok Build',
+    logo: BUILTIN_LOGOS.grok,
+    bin: 'grok',
+    installUrl: 'https://docs.x.ai/build/overview',
+    selectVar: 'GROK_HOME',
+    layout: { main: '.grok', account: '.grok-<name>' },
+    hijackVars: ['XAI_API_KEY', 'GROK_MODELS_BASE_URL'],
+    apiVars: ['GROK_MODELS_BASE_URL', 'XAI_API_KEY'],
+    sharedItems: [
+        { path: 'skills', mode: 'link' },
+        { path: 'installed-plugins', mode: 'link' },
+        { path: 'hooks', mode: 'copy', hostMessage: HOOKS_DIR_MESSAGE },
+        { path: 'hooks-paths', mode: 'copy', hostMessage: REAL_FILE_MESSAGE },
+        { path: 'trusted_folders.toml', mode: 'local', hostMessage: REAL_FILE_MESSAGE },
+        { path: 'config.toml', mode: 'local-if-api', noSymlink: true, hostMessage: REAL_FILE_MESSAGE },
+        { path: 'auth.json', mode: 'info', noSymlink: true, credential: true, hostMessage: AUTH_MESSAGE },
+    ],
+    login: {
+        args: ['login'],
+        hint: "Sign in to your xAI account in the browser; the login is saved to this account's auth.json",
+    },
+    async loginState(account) {
+        try {
+            const st = await lstat(join(account.dir, 'auth.json'));
+            return st.isFile() ? 'logged-in' : 'unknown';
+        }
+        catch (err) {
+            return err.code === 'ENOENT' ? 'logged-out' : 'unknown';
+        }
+    },
+    model: readModel,
+    identity: grokIdentity,
+};
+export const grokPlugin = {
+    name: 'grok',
+    register(api) {
+        api.family(grokFamily);
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { BuiltinPlugin } from '../plugins/loader.ts';
+/** Built-in Plugins in load order. Families register here; `account-script` is off unless enabled. */
+export declare const BUILTIN_PLUGINS: BuiltinPlugin[];

package/dist/src/families/index.js

@@ -0,0 +1,40 @@
+import { packageVersion } from '../core/version.js';
+import { accountScript } from '../plugins/account-script.js';
+import { claudePlugin } from './claude/index.js';
+import { codexPlugin } from './codex/index.js';
+import { grokPlugin } from './grok/index.js';
+import { piPlugin } from './pi/index.js';
+const VERSION = packageVersion();
+/** Built-in Plugins in load order. Families register here; `account-script` is off unless enabled. */
+export const BUILTIN_PLUGINS = [
+    {
+        plugin: claudePlugin,
+        version: VERSION,
+        description: 'Claude Code family (~/.claude, CLAUDE_CONFIG_DIR)',
+        defaultEnabled: true,
+    },
+    {
+        plugin: codexPlugin,
+        version: VERSION,
+        description: 'Codex family (~/.codex, CODEX_HOME)',
+        defaultEnabled: true,
+    },
+    {
+        plugin: grokPlugin,
+        version: VERSION,
+        description: 'Grok Build family (~/.grok, GROK_HOME)',
+        defaultEnabled: true,
+    },
+    {
+        plugin: piPlugin,
+        version: VERSION,
+        description: 'pi family (~/.pi/agent, PI_CODING_AGENT_DIR)',
+        defaultEnabled: true,
+    },
+    {
+        plugin: accountScript,
+        version: VERSION,
+        description: 'Run <account>/sideby-before-launch before each launch',
+        defaultEnabled: false,
+    },
+];

package/dist/src/families/logos.d.ts

@@ -0,0 +1,21 @@
+/** Logos of the built-in Families, by Family id; each Family sets its own as `logo`. */
+export declare const BUILTIN_LOGOS: {
+    claude: {
+        title: string;
+        color: string;
+        path: string;
+    };
+    codex: {
+        title: string;
+        path: string;
+    };
+    grok: {
+        title: string;
+        fillRule: "evenodd";
+        path: string;
+    };
+    pi: {
+        title: string;
+        path: string;
+    };
+};

package/dist/src/families/logos.js

@@ -0,0 +1,26 @@
+// Built-in Family marks for the Panel (FamilyDef.logo): 24x24 single-path SVG icons, drawn inline because the page CSP
+// allows no external images.
+// Sources: Claude, OpenAI and pi from Simple Icons (CC0 1.0, https://simpleicons.org; OpenAI from v15.0.0, the last release
+// that ships it; pi is the mark from https://pi.dev). Grok from LobeHub Icons (MIT, Copyright (c) 2023 LobeHub,
+// https://github.com/lobehub/lobe-icons). The marks are trademarks of their owners and only identify each Host.
+/** Logos of the built-in Families, by Family id; each Family sets its own as `logo`. */
+export const BUILTIN_LOGOS = {
+    claude: {
+        title: 'Claude',
+        color: '#D97757',
+        path: 'm4.7144 15.9555 4.7174-2.6471.079-.2307-.079-.1275h-.2307l-.7893-.0486-2.6956-.0729-2.3375-.0971-2.2646-.1214-.5707-.1215-.5343-.7042.0546-.3522.4797-.3218.686.0608 1.5179.1032 2.2767.1578 1.6514.0972 2.4468.255h.3886l.0546-.1579-.1336-.0971-.1032-.0972L6.973 9.8356l-2.55-1.6879-1.3356-.9714-.7225-.4918-.3643-.4614-.1578-1.0078.6557-.7225.8803.0607.2246.0607.8925.686 1.9064 1.4754 2.4893 1.8336.3643.3035.1457-.1032.0182-.0728-.164-.2733-1.3539-2.4467-1.445-2.4893-.6435-1.032-.17-.6194c-.0607-.255-.1032-.4674-.1032-.7285L6.287.1335 6.6997 0l.9957.1336.419.3642.6192 1.4147 1.0018 2.2282 1.5543 3.0296.4553.8985.2429.8318.091.255h.1579v-.1457l.1275-1.706.2368-2.0947.2307-2.6957.0789-.7589.3764-.9107.7468-.4918.5828.2793.4797.686-.0668.4433-.2853 1.8517-.5586 2.9021-.3643 1.9429h.2125l.2429-.2429.9835-1.3053 1.6514-2.0643.7286-.8196.85-.9046.5464-.4311h1.0321l.759 1.1293-.34 1.1657-1.0625 1.3478-.8804 1.1414-1.2628 1.7-.7893 1.36.0729.1093.1882-.0183 2.8535-.607 1.5421-.2794 1.8396-.3157.8318.3886.091.3946-.3278.8075-1.967.4857-2.3072.4614-3.4364.8136-.0425.0304.0486.0607 1.5482.1457.6618.0364h1.621l3.0175.2247.7892.522.4736.6376-.079.4857-1.2142.6193-1.6393-.3886-3.825-.9107-1.3113-.3279h-.1822v.1093l1.0929 1.0686 2.0035 1.8092 2.5075 2.3314.1275.5768-.3218.4554-.34-.0486-2.2039-1.6575-.85-.7468-1.9246-1.621h-.1275v.17l.4432.6496 2.3436 3.5214.1214 1.0807-.17.3521-.6071.2125-.6679-.1214-1.3721-1.9246L14.38 17.959l-1.1414-1.9428-.1397.079-.674 7.2552-.3156.3703-.7286.2793-.6071-.4614-.3218-.7468.3218-1.4753.3886-1.9246.3157-1.53.2853-1.9004.17-.6314-.0121-.0425-.1397.0182-1.4328 1.9672-2.1796 2.9446-1.7243 1.8456-.4128.164-.7164-.3704.0667-.6618.4008-.5889 2.386-3.0357 1.4389-1.882.929-1.0868-.0062-.1579h-.0546l-6.3385 4.1164-1.1293.1457-.4857-.4554.0608-.7467.2307-.2429 1.9064-1.3114Z',
+    },
+    codex: {
+        title: 'OpenAI',
+        path: 'M22.2819 9.8211a5.9847 5.9847 0 0 0-.5157-4.9108 6.0462 6.0462 0 0 0-6.5098-2.9A6.0651 6.0651 0 0 0 4.9807 4.1818a5.9847 5.9847 0 0 0-3.9977 2.9 6.0462 6.0462 0 0 0 .7427 7.0966 5.98 5.98 0 0 0 .511 4.9107 6.051 6.051 0 0 0 6.5146 2.9001A5.9847 5.9847 0 0 0 13.2599 24a6.0557 6.0557 0 0 0 5.7718-4.2058 5.9894 5.9894 0 0 0 3.9977-2.9001 6.0557 6.0557 0 0 0-.7475-7.0729zm-9.022 12.6081a4.4755 4.4755 0 0 1-2.8764-1.0408l.1419-.0804 4.7783-2.7582a.7948.7948 0 0 0 .3927-.6813v-6.7369l2.02 1.1686a.071.071 0 0 1 .038.052v5.5826a4.504 4.504 0 0 1-4.4945 4.4944zm-9.6607-4.1254a4.4708 4.4708 0 0 1-.5346-3.0137l.142.0852 4.783 2.7582a.7712.7712 0 0 0 .7806 0l5.8428-3.3685v2.3324a.0804.0804 0 0 1-.0332.0615L9.74 19.9502a4.4992 4.4992 0 0 1-6.1408-1.6464zM2.3408 7.8956a4.485 4.485 0 0 1 2.3655-1.9728V11.6a.7664.7664 0 0 0 .3879.6765l5.8144 3.3543-2.0201 1.1685a.0757.0757 0 0 1-.071 0l-4.8303-2.7865A4.504 4.504 0 0 1 2.3408 7.872zm16.5963 3.8558L13.1038 8.364 15.1192 7.2a.0757.0757 0 0 1 .071 0l4.8303 2.7913a4.4944 4.4944 0 0 1-.6765 8.1042v-5.6772a.79.79 0 0 0-.407-.667zm2.0107-3.0231l-.142-.0852-4.7735-2.7818a.7759.7759 0 0 0-.7854 0L9.409 9.2297V6.8974a.0662.0662 0 0 1 .0284-.0615l4.8303-2.7866a4.4992 4.4992 0 0 1 6.6802 4.66zM8.3065 12.863l-2.02-1.1638a.0804.0804 0 0 1-.038-.0567V6.0742a4.4992 4.4992 0 0 1 7.3757-3.4537l-.142.0805L8.704 5.459a.7948.7948 0 0 0-.3927.6813zm1.0976-2.3654l2.602-1.4998 2.6069 1.4998v2.9994l-2.5974 1.4997-2.6067-1.4997Z',
+    },
+    grok: {
+        title: 'Grok',
+        fillRule: 'evenodd',
+        path: 'M9.27 15.29l7.978-5.897c.391-.29.95-.177 1.137.272.98 2.369.542 5.215-1.41 7.169-1.951 1.954-4.667 2.382-7.149 1.406l-2.711 1.257c3.889 2.661 8.611 2.003 11.562-.953 2.341-2.344 3.066-5.539 2.388-8.42l.006.007c-.983-4.232.242-5.924 2.75-9.383.06-.082.12-.164.179-.248l-3.301 3.305v-.01L9.267 15.292M7.623 16.723c-2.792-2.67-2.31-6.801.071-9.184 1.761-1.763 4.647-2.483 7.166-1.425l2.705-1.25a7.808 7.808 0 00-1.829-1A8.975 8.975 0 005.984 5.83c-2.533 2.536-3.33 6.436-1.962 9.764 1.022 2.487-.653 4.246-2.34 6.022-.599.63-1.199 1.259-1.682 1.925l7.62-6.815',
+    },
+    pi: {
+        title: 'pi',
+        path: 'M0 0v24h6v-6h6v-6H6V6h6v6h6V0Zm18 12v12h6V12Z',
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { FamilyDef, Plugin } from '../../types.ts';
+export declare const piFamily: FamilyDef;
+export declare const piPlugin: Plugin;

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

@@ -0,0 +1,54 @@
+// Built-in Family Plugin for pi (spec §3.4, checked against pi 1.0.2). pi keeps each Account one level
+// deeper (`~/.pi-<name>/agent`) and signs in inside the app, so there is no login command.
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { lstatOrNull } from '../../core/fs-safe.js';
+import { BUILTIN_LOGOS } from '../logos.js';
+/** `auth.json` exists after `/login`; its contents are never read. */
+async function loginState(account) {
+    return (await lstatOrNull(join(account.dir, 'auth.json'))) ? 'logged-in' : 'logged-out';
+}
+async function model(account) {
+    try {
+        const s = JSON.parse(await readFile(join(account.dir, 'settings.json'), 'utf8'));
+        const provider = typeof s?.defaultProvider === 'string' ? s.defaultProvider : '';
+        const id = typeof s?.defaultModel === 'string' ? s.defaultModel : '';
+        if (!id)
+            return undefined;
+        return provider ? `${provider}/${id}` : id;
+    }
+    catch {
+        return undefined;
+    }
+}
+export const piFamily = {
+    id: 'pi',
+    title: 'pi',
+    logo: BUILTIN_LOGOS.pi,
+    bin: 'pi',
+    installUrl: 'https://github.com/earendil-works/pi',
+    selectVar: 'PI_CODING_AGENT_DIR',
+    secretFileMeansApi: false,
+    layout: { main: '.pi/agent', account: '.pi-<name>/agent' },
+    hijackVars: [
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_BASE_URL',
+        'OPENAI_API_KEY',
+        'OPENAI_BASE_URL',
+    ],
+    apiVars: ['ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'OPENAI_API_KEY', 'OPENAI_BASE_URL'],
+    sharedItems: [
+        { path: 'AGENTS.md', mode: 'link' },
+        { path: 'auth.json', mode: 'info', credential: true },
+    ],
+    login: { args: null, hint: 'pi signs in inside the app: start it and type /login' },
+    loginState,
+    model,
+};
+export const piPlugin = {
+    name: 'pi',
+    register(api) {
+        api.family(piFamily);
+    },
+};

package/dist/src/families/shared/toml.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `key = "value"` among the top-level keys of a TOML file, i.e. before the first `[table]` header.
+ * Only a whole-line header ends the top level, so a multi-line array line such as `  ["a"],` does not.
+ */
+export declare function topLevelTomlString(text: string, key: string): string | undefined;

package/dist/src/families/shared/toml.js

@@ -0,0 +1,16 @@
+const TABLE_HEADER = /^\s*\[\[?[^\]\s][^\]]*\]\]?\s*(#.*)?$/;
+/**
+ * `key = "value"` among the top-level keys of a TOML file, i.e. before the first `[table]` header.
+ * Only a whole-line header ends the top level, so a multi-line array line such as `  ["a"],` does not.
+ */
+export function topLevelTomlString(text, key) {
+    const pattern = new RegExp(`^\\s*${key}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`);
+    for (const line of text.split(/\r?\n/)) {
+        if (TABLE_HEADER.test(line) && !/^\s*\[\s*["'\d]/.test(line))
+            return undefined;
+        const m = pattern.exec(line);
+        if (m)
+            return m[1] ?? m[2];
+    }
+    return undefined;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { createPanelHandler, type PanelFamily, type PanelHandler, type PanelHandlerOptions, type PanelState, } from './panel/handler.ts';
+export { startPanelServer } from './panel/server.ts';
+export type { PanelTheme, PanelThemeTokens } from './panel/theme.ts';
+export { type AccountStatus, createRuntime, type DoctorOptions, type FamilyInfo, type Runtime, } from './runtime.ts';
+export type * from './types.ts';

package/dist/src/index.js

@@ -0,0 +1,4 @@
+// Library entry: the Panel handler for embedding, the Runtime for tools built on sideby, and Plugin types.
+export { createPanelHandler, } from './panel/handler.js';
+export { startPanelServer } from './panel/server.js';
+export { createRuntime, } from './runtime.js';

package/dist/src/panel/background.d.ts

@@ -0,0 +1,62 @@
+import type { Paths } from '../core/paths.ts';
+import type { Env } from '../types.ts';
+export declare const DETACHED_FLAG = "serve-detached";
+export interface PanelPidFile {
+    pid: number;
+    port: number;
+    url: string;
+    startedAt: string;
+    /** Random id the Panel also returns on `/api/health`. */
+    instance: string;
+    /** `ps -o lstart=` of the process, when `ps` gave one; a reused pid has another. */
+    processStart?: string;
+}
+export declare const pidFilePath: (p: Paths) => string;
+export declare const logFilePath: (p: Paths) => string;
+export declare function readPidFile(p: Paths): Promise<PanelPidFile | undefined>;
+/** When `pid` started, as `ps` prints it; with the pid it names one process, which a reused pid does not match. */
+export declare const processStartTime: (pid: number) => Promise<string | undefined>;
+/** URL of a running background Panel, or of any sideby Panel on `port`; removes a stale pid file. */
+export declare function findRunningPanel(p: Paths, port: number): Promise<string | undefined>;
+export interface StartBackgroundOptions {
+    paths: Paths;
+    env: Env;
+    /** Absolute path of the sideby CLI entry the detached process runs. */
+    entry: string;
+    port?: number;
+}
+/**
+ * Makes sure one background Panel runs and returns its URL. Reuses a running one; otherwise starts
+ * `sideby ui --serve-detached` in its own session, logging to the state directory, and waits until it listens.
+ */
+export declare function startBackgroundPanel(opts: StartBackgroundOptions): Promise<{
+    url: string;
+    reused: boolean;
+    pid?: number;
+    replaced?: boolean;
+}>;
+/**
+ * Body of the detached process: serve the Panel with Hosts found through the login shell's PATH, tell the
+ * launching process the URL over IPC, keep the pid file while running, and remove it on SIGTERM or SIGINT.
+ */
+export declare function serveDetached(opts: {
+    paths: Paths;
+    env: Env;
+    port?: number;
+    runtimeFactory: (env: Env) => Promise<import('../runtime.ts').Runtime>;
+    log: (s: string) => void;
+}): Promise<number>;
+export type StopResult = {
+    status: 'stopped';
+    pid: number;
+    url: string;
+} | {
+    status: 'not-running';
+    detail?: string;
+} | {
+    status: 'failed';
+    pid: number;
+    detail: string;
+};
+/** Stops the background Panel named in the pid file, signalling it only when checkPanel confirms it. */
+export declare function stopBackgroundPanel(paths: Paths): Promise<StopResult>;