vibe-usage-cli 0.0.0-stage → 0.1.1

package/build/core/settings.d.ts

@@ -0,0 +1,16 @@
+import type { ProjectPreference, QuietHours, Settings, SettingsNotice } from '../shared/types.ts';
+export declare function defaultSettings(): Settings;
+export declare function validateConfigDir(value: unknown, platform?: NodeJS.Platform): string;
+export declare const projectPreference: (settings: Pick<Settings, "projectPreferences">, projectDir: string) => ProjectPreference | null;
+export declare function inQuietHours(quietHours: QuietHours | undefined, date: Date): boolean;
+export declare function validateSettings(document: unknown): Settings;
+export declare function appDataDir(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export declare const settingsPath: (dataDir: string) => string;
+export declare const backupPath: (file: string) => string;
+export declare function loadSettings(file: string): Promise<Settings | null>;
+export interface LoadedSettings {
+    settings: Settings;
+    notice?: SettingsNotice;
+}
+export declare function loadSettingsWithRecovery(file: string): Promise<LoadedSettings>;
+export declare function saveSettings(file: string, input: unknown): Promise<Settings>;

package/build/core/settings.js

@@ -0,0 +1,377 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { ACCOUNT_ID_PATTERN, ACCOUNT_LABEL_KEYS, ACCOUNT_ORIGINS, APP_NAME, AUTO_CONTINUE, AUTOMATION_MODES, INHERIT, isOneOf, isProviderId, LOW_QUOTA_PERCENT, LOW_QUOTA_RANGE, MAX_DISMISSED_ACCOUNTS, MAX_LABEL_LENGTH, MODEL_ID_PATTERN, PROVIDER_IDS, providerById, REFRESH_INTERVAL_SECONDS } from "../shared/catalog.js";
+import { DEFAULT_LANGUAGE, isLanguage } from "../shared/i18n/index.js";
+import { AppError, InvalidSettingsError, systemErrorCode } from "./errors.js";
+import { isObject, parseJson, pathKey, samePath, writeFileAtomic } from "./files.js";
+import { hasControlChars, normalizeEmail } from "./model.js";
+const SETTINGS_SCHEMA_VERSION = 1;
+const SETTINGS_FILE = 'settings.json';
+// The last document that validated before it was replaced.
+const BACKUP_SUFFIX = '.bak';
+// An unreadable document is kept beside the new one under this suffix and a timestamp.
+const DAMAGED_SUFFIX = '.damaged-';
+const MAX_PROJECT_PREFERENCES = 100;
+const TIME_OF_DAY = /^(?:[01]\d|2[0-3]):[0-5]\d$/;
+const MAX_ACCOUNTS = 40;
+const MAX_EMAIL_LENGTH = 256;
+const MAX_PATH_LENGTH = 1024;
+const WINDOW_BOUNDS = { maxOffset: 100000, minWidth: 280, maxWidth: 3000, minHeight: 300, maxHeight: 3000 };
+const SETTINGS_KEYS = [
+    'schemaVersion',
+    'pinned',
+    'intervalSeconds',
+    'accounts',
+    'window',
+    'dismissedAccountIds',
+    'providerOrder',
+    'homeOrder',
+    'preferredModels',
+    'language',
+    'notifications',
+    'compareAccounts',
+    'autoContinue',
+    'returnToPrimary',
+    'reopenAfterRestart',
+    'compact',
+    'checkUpdates',
+    'projectPreferences',
+    'lowQuotaPercent',
+    'quietHours'
+];
+const PREFERENCE_KEYS = ['projectDir', 'tool', 'model', 'accountId', 'autoContinue'];
+const QUIET_HOURS_KEYS = ['start', 'end'];
+const ACCOUNT_KEYS = [
+    'id',
+    'providerId',
+    'label',
+    'labelKey',
+    'configDir',
+    'primary',
+    'enabled',
+    'configDirExplicit',
+    'origin',
+    'signInUntil',
+    'email'
+];
+const WINDOW_KEYS = ['x', 'y', 'width', 'height'];
+export function defaultSettings() {
+    return {
+        schemaVersion: SETTINGS_SCHEMA_VERSION,
+        pinned: false,
+        intervalSeconds: REFRESH_INTERVAL_SECONDS.default,
+        accounts: [],
+        dismissedAccountIds: [],
+        providerOrder: [...PROVIDER_IDS],
+        preferredModels: {},
+        language: DEFAULT_LANGUAGE,
+        notifications: false,
+        compareAccounts: false,
+        autoContinue: 'off',
+        returnToPrimary: 'ask',
+        reopenAfterRestart: 'ask',
+        compact: false,
+        checkUpdates: true,
+        projectPreferences: [],
+        lowQuotaPercent: LOW_QUOTA_PERCENT
+    };
+}
+function assertShape(value, allowed, reason) {
+    if (!isObject(value) || Object.keys(value).some(key => !allowed.includes(key)))
+        throw new InvalidSettingsError(reason);
+}
+function check(condition, reason) {
+    if (!condition)
+        throw new InvalidSettingsError(reason);
+}
+// An absolute, local (no UNC share) directory path without parent traversal. On Windows it
+// names its drive: `\Repo` would depend on the current one.
+export function validateConfigDir(value, platform = process.platform) {
+    if (typeof value !== 'string' ||
+        value.length > MAX_PATH_LENGTH ||
+        hasControlChars(value) ||
+        /^[/\\]{2}/.test(value) ||
+        value.split(/[\\/]/).includes('..') ||
+        !path.isAbsolute(value) ||
+        (platform === 'win32' && !/^[A-Za-z]:[\\/]/.test(value)))
+        throw new AppError('invalid_path');
+    return path.normalize(value);
+}
+const isOptionalBoolean = (value) => value === undefined || typeof value === 'boolean';
+function validateAccount(input, ids, primaries) {
+    assertShape(input, ACCOUNT_KEYS, 'unknown_account_setting');
+    const { id, providerId, labelKey, configDir, configDirExplicit, origin, signInUntil, email, primary, enabled } = input;
+    check(typeof id === 'string' && ACCOUNT_ID_PATTERN.test(id) && !ids.has(id) && isProviderId(providerId), 'invalid_account');
+    ids.add(id);
+    const label = typeof input.label === 'string' ? input.label.slice(0, MAX_LABEL_LENGTH).trim() : '';
+    // A typed name is shown instead of the app's key, which stays: clearing the name brings it
+    // back. Without either, the account is shown by its sign-in.
+    check(labelKey === undefined || isOneOf(ACCOUNT_LABEL_KEYS, labelKey), 'invalid_account_label');
+    check(!hasControlChars(label), 'invalid_account_label');
+    check(typeof primary === 'boolean' && typeof enabled === 'boolean' && isOptionalBoolean(configDirExplicit), 'invalid_account_flags');
+    check(origin === undefined || isOneOf(ACCOUNT_ORIGINS, origin), 'invalid_account_flags');
+    check(signInUntil === undefined || (typeof signInUntil === 'number' && Number.isFinite(signInUntil)), 'invalid_account_flags');
+    check(email === undefined || (typeof email === 'string' && email.length <= MAX_EMAIL_LENGTH && !hasControlChars(email)), 'invalid_account_flags');
+    check(!(primary && primaries.has(providerId)), 'duplicate_primary');
+    if (primary)
+        primaries.add(providerId);
+    return {
+        id,
+        providerId,
+        ...(label ? { label } : {}),
+        ...(isOneOf(ACCOUNT_LABEL_KEYS, labelKey) ? { labelKey } : {}),
+        ...(configDir === undefined ? {} : { configDir: validateConfigDir(configDir) }),
+        ...(configDirExplicit === undefined ? {} : { configDirExplicit }),
+        ...(origin === undefined ? {} : { origin }),
+        // Only a pending account waits for a sign-in; without a time, its sign-in is closed.
+        ...(origin === 'pending' && typeof signInUntil === 'number' ? { signInUntil } : {}),
+        ...(email === undefined ? {} : { email: normalizeEmail(email) }),
+        primary,
+        enabled
+    };
+}
+function validateWindow(value) {
+    assertShape(value, WINDOW_KEYS, 'invalid_window');
+    const { x, y, width, height } = value;
+    const b = WINDOW_BOUNDS;
+    const isInteger = (n) => Number.isInteger(n);
+    check(isInteger(x) &&
+        isInteger(y) &&
+        isInteger(width) &&
+        isInteger(height) &&
+        Math.abs(x) <= b.maxOffset &&
+        Math.abs(y) <= b.maxOffset &&
+        width >= b.minWidth &&
+        width <= b.maxWidth &&
+        height >= b.minHeight &&
+        height <= b.maxHeight, 'invalid_window');
+    return { x, y, width, height };
+}
+function validateProviderOrder(value) {
+    check(Array.isArray(value) && value.length <= PROVIDER_IDS.length && new Set(value).size === value.length && value.every(isProviderId), 'invalid_provider_order');
+    return value;
+}
+function validatePreferredModels(value) {
+    assertShape(value, PROVIDER_IDS, 'invalid_preferred_models');
+    const models = {};
+    for (const [providerId, model] of Object.entries(value)) {
+        // Tools opened as apps take no model argument.
+        check(isProviderId(providerId) && providerById(providerId).acceptsModel && typeof model === 'string' && MODEL_ID_PATTERN.test(model), 'invalid_preferred_models');
+        models[providerId] = model;
+    }
+    return models;
+}
+function validateDismissed(value) {
+    const isAccountId = (id) => typeof id === 'string' && ACCOUNT_ID_PATTERN.test(id);
+    check(Array.isArray(value) && value.every(isAccountId), 'invalid_dismissed_accounts');
+    return [...new Set(value)].slice(-MAX_DISMISSED_ACCOUNTS);
+}
+// Folders compare the way the file systems name them by default: case-insensitively on Windows
+// and macOS, as session folders are matched.
+export const projectPreference = (settings, projectDir) => settings.projectPreferences.find(p => samePath(p.projectDir, projectDir)) ?? null;
+// A preferred account may since have been removed: it is checked where it is used, so that
+// removing an account never makes the settings invalid.
+function validateProjectPreference(input, seen) {
+    assertShape(input, PREFERENCE_KEYS, 'invalid_project_preference');
+    const { tool, model, accountId, autoContinue } = input;
+    const projectDir = validateConfigDir(input.projectDir);
+    check(!seen.has(pathKey(projectDir)), 'duplicate_project_preference');
+    seen.add(pathKey(projectDir));
+    check(tool === undefined || isProviderId(tool), 'invalid_project_preference');
+    check(model === undefined ||
+        (tool !== undefined && providerById(tool).acceptsModel && typeof model === 'string' && MODEL_ID_PATTERN.test(model)), 'invalid_project_preference');
+    check(accountId === undefined || (typeof accountId === 'string' && ACCOUNT_ID_PATTERN.test(accountId)), 'invalid_project_preference');
+    check(autoContinue === undefined || autoContinue === INHERIT || isOneOf(AUTO_CONTINUE, autoContinue), 'invalid_project_preference');
+    return {
+        projectDir,
+        ...(tool === undefined ? {} : { tool }),
+        ...(model === undefined ? {} : { model }),
+        ...(accountId === undefined ? {} : { accountId }),
+        autoContinue: autoContinue ?? INHERIT
+    };
+}
+function validateProjectPreferences(value) {
+    check(Array.isArray(value) && value.length <= MAX_PROJECT_PREFERENCES, 'invalid_project_preference');
+    const seen = new Set();
+    return value.map(entry => validateProjectPreference(entry, seen));
+}
+// Equal times would be an empty or a whole-day span; neither is a useful setting.
+function validateQuietHours(value) {
+    assertShape(value, QUIET_HOURS_KEYS, 'invalid_quiet_hours');
+    const { start, end } = value;
+    check(typeof start === 'string' && typeof end === 'string' && TIME_OF_DAY.test(start) && TIME_OF_DAY.test(end), 'invalid_quiet_hours');
+    check(start !== end, 'invalid_quiet_hours');
+    return { start, end };
+}
+const minutesOfDay = (time) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
+// Whether `date` (local time) falls in the quiet hours; the start is included, the end is not.
+export function inQuietHours(quietHours, date) {
+    if (!quietHours)
+        return false;
+    const now = date.getHours() * 60 + date.getMinutes();
+    const start = minutesOfDay(quietHours.start);
+    const end = minutesOfDay(quietHours.end);
+    return start < end ? now >= start && now < end : now >= start || now < end;
+}
+const isFutureDocument = (document) => isObject(document) && typeof document.schemaVersion === 'number' && document.schemaVersion > SETTINGS_SCHEMA_VERSION;
+// Complete settings from a stored or patched document; absent optional fields get defaults.
+// A document without a version predates versioning and reads as version 1 unchanged.
+// Settings an earlier version wrote that no longer exist: a file that has them is read without
+// them (and saved without them next time), rather than refused as unknown.
+const RETIRED_SETTINGS = ['globalShortcut'];
+export function validateSettings(document) {
+    const input = isObject(document)
+        ? Object.fromEntries(Object.entries(document).filter(([key]) => !RETIRED_SETTINGS.includes(key)))
+        : document;
+    assertShape(input, SETTINGS_KEYS, 'unknown_setting');
+    check(!isFutureDocument(input), 'unsupported_schema');
+    check(input.schemaVersion === undefined || input.schemaVersion === SETTINGS_SCHEMA_VERSION, 'invalid_schema_version');
+    const { pinned, intervalSeconds, accounts, language, notifications, compareAccounts, autoContinue, returnToPrimary, reopenAfterRestart, compact, checkUpdates } = input;
+    check(typeof pinned === 'boolean', 'invalid_pinned');
+    check(isOptionalBoolean(notifications), 'invalid_notifications');
+    check(isOptionalBoolean(compareAccounts), 'invalid_compare_accounts');
+    check(autoContinue === undefined || isOneOf(AUTO_CONTINUE, autoContinue), 'invalid_auto_continue');
+    check(returnToPrimary === undefined || isOneOf(AUTOMATION_MODES, returnToPrimary), 'invalid_settings');
+    check(reopenAfterRestart === undefined || isOneOf(AUTOMATION_MODES, reopenAfterRestart), 'invalid_settings');
+    check(isOptionalBoolean(compact) && isOptionalBoolean(checkUpdates), 'invalid_settings');
+    check(typeof intervalSeconds === 'number' &&
+        Number.isInteger(intervalSeconds) &&
+        intervalSeconds >= REFRESH_INTERVAL_SECONDS.min &&
+        intervalSeconds <= REFRESH_INTERVAL_SECONDS.max, 'invalid_interval');
+    check(Array.isArray(accounts) && accounts.length <= MAX_ACCOUNTS, 'invalid_accounts');
+    check(language === undefined || isLanguage(language), 'invalid_language');
+    const { lowQuotaPercent } = input;
+    check(lowQuotaPercent === undefined ||
+        (Number.isInteger(lowQuotaPercent) &&
+            typeof lowQuotaPercent === 'number' &&
+            lowQuotaPercent >= LOW_QUOTA_RANGE.min &&
+            lowQuotaPercent <= LOW_QUOTA_RANGE.max), 'invalid_low_quota_percent');
+    const ids = new Set();
+    const primaries = new Set();
+    const defaults = defaultSettings();
+    return {
+        schemaVersion: SETTINGS_SCHEMA_VERSION,
+        pinned,
+        intervalSeconds,
+        accounts: accounts.map(account => validateAccount(account, ids, primaries)),
+        dismissedAccountIds: input.dismissedAccountIds === undefined ? defaults.dismissedAccountIds : validateDismissed(input.dismissedAccountIds),
+        providerOrder: input.providerOrder === undefined ? defaults.providerOrder : validateProviderOrder(input.providerOrder),
+        preferredModels: input.preferredModels === undefined ? defaults.preferredModels : validatePreferredModels(input.preferredModels),
+        language: language ?? defaults.language,
+        notifications: notifications ?? defaults.notifications,
+        compareAccounts: compareAccounts ?? defaults.compareAccounts,
+        autoContinue: autoContinue ?? defaults.autoContinue,
+        returnToPrimary: returnToPrimary ?? defaults.returnToPrimary,
+        reopenAfterRestart: reopenAfterRestart ?? defaults.reopenAfterRestart,
+        compact: compact ?? defaults.compact,
+        checkUpdates: checkUpdates ?? defaults.checkUpdates,
+        projectPreferences: input.projectPreferences === undefined ? defaults.projectPreferences : validateProjectPreferences(input.projectPreferences),
+        lowQuotaPercent: lowQuotaPercent ?? defaults.lowQuotaPercent,
+        // null clears the quiet hours: an absent field would keep the current ones in a patch.
+        ...(input.quietHours === undefined || input.quietHours === null ? {} : { quietHours: validateQuietHours(input.quietHours) }),
+        ...(input.homeOrder === undefined ? {} : { homeOrder: validateProviderOrder(input.homeOrder) }),
+        ...(input.window === undefined ? {} : { window: validateWindow(input.window) })
+    };
+}
+// Where the app keeps its data: VIBE_DATA_DIR, else the platform's per-user app data folder
+// (the same folder Electron's `userData` resolves to).
+export function appDataDir(env = process.env, platform = process.platform) {
+    if (env.VIBE_DATA_DIR)
+        return path.resolve(env.VIBE_DATA_DIR);
+    const root = platform === 'win32'
+        ? (env.APPDATA ?? path.join(os.homedir(), 'AppData/Roaming'))
+        : platform === 'darwin'
+            ? path.join(os.homedir(), 'Library/Application Support')
+            : (env.XDG_CONFIG_HOME ?? path.join(os.homedir(), '.config'));
+    return path.join(root, APP_NAME);
+}
+export const settingsPath = (dataDir) => path.join(dataDir, SETTINGS_FILE);
+export const backupPath = (file) => `${file}${BACKUP_SUFFIX}`;
+async function readText(file) {
+    try {
+        return await fsp.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (systemErrorCode(error) === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+// A file that is there but cannot be read (no permission, a folder in its place) counts as
+// damaged; only a missing one is absent.
+const UNREADABLE = Symbol('unreadable');
+const readStored = (file) => readText(file).catch(() => UNREADABLE);
+function parseSettings(text) {
+    let document;
+    try {
+        document = parseJson(text);
+    }
+    catch {
+        throw new InvalidSettingsError('malformed_file');
+    }
+    return validateSettings(document);
+}
+// The stored settings, or null when none were saved yet.
+export async function loadSettings(file) {
+    const text = await readText(file);
+    return text === null ? null : parseSettings(text);
+}
+// The settings to start with. A damaged or unreadable file falls back to the backup, else to
+// defaults; a newer version's file (or backup) to defaults, locked. Nothing is written here:
+// the evidence stays as it is.
+export async function loadSettingsWithRecovery(file) {
+    const text = await readStored(file);
+    if (text === null)
+        return { settings: defaultSettings() };
+    if (text !== UNREADABLE) {
+        if (isFutureDocument(attemptParse(text)))
+            return { settings: defaultSettings(), notice: 'future' };
+        const settings = attemptValidate(text);
+        if (settings)
+            return { settings };
+    }
+    const backup = await readStored(backupPath(file));
+    if (typeof backup === 'string' && isFutureDocument(attemptParse(backup)))
+        return { settings: defaultSettings(), notice: 'future' };
+    const restored = typeof backup === 'string' ? attemptValidate(backup) : null;
+    return restored ? { settings: restored, notice: 'recovered' } : { settings: defaultSettings(), notice: 'unrecoverable' };
+}
+function attemptParse(text) {
+    try {
+        return parseJson(text);
+    }
+    catch {
+        return null;
+    }
+}
+function attemptValidate(text) {
+    try {
+        return parseSettings(text);
+    }
+    catch {
+        return null;
+    }
+}
+// Validates and writes atomically: a crash mid-write never leaves a truncated file. The
+// document it replaces becomes the backup when it was valid, or is kept aside when it was
+// not; a newer version's document is never replaced.
+export async function saveSettings(file, input) {
+    const settings = validateSettings(input);
+    const previous = await readStored(file);
+    if (typeof previous === 'string' && isFutureDocument(attemptParse(previous)))
+        throw new AppError('settings_locked');
+    if (typeof previous === 'string' && attemptValidate(previous))
+        await keepBackup(file, previous);
+    else if (previous !== null)
+        await fsp.rename(file, `${file}${DAMAGED_SUFFIX}${new Date().toISOString().replace(/[:.]/g, '-')}`);
+    await writeFileAtomic(file, `${JSON.stringify(settings, null, 2)}\n`);
+    return settings;
+}
+// A newer version's backup is its last good document: it is kept rather than replaced.
+async function keepBackup(file, previous) {
+    const backup = await readStored(backupPath(file));
+    if (typeof backup === 'string' && isFutureDocument(attemptParse(backup)))
+        return;
+    await writeFileAtomic(backupPath(file), previous);
+}

package/build/core/tray-icon.d.ts

@@ -0,0 +1,5 @@
+type Rgba = readonly [number, number, number, number];
+export declare const quotaColor: (percent: number, lowPercent?: number) => Rgba;
+export declare function ringPixels(size: number, percent: number | null, lowPercent?: number): Buffer;
+export declare const ringIcon: (size: number, percent: number | null, lowPercent?: number) => Buffer;
+export {};

package/build/core/tray-icon.js

@@ -0,0 +1,91 @@
+// The tray icon as a ring that fills with the quota left, drawn here and encoded as PNG so
+// that it needs no image library and looks the same on every platform.
+import zlib from 'node:zlib';
+import { LOW_QUOTA_PERCENT } from "../shared/catalog.js";
+const AMPLE_PERCENT = 50;
+const COLORS = {
+    ample: [34, 197, 94, 255],
+    some: [245, 158, 11, 255],
+    low: [239, 68, 68, 255],
+    track: [128, 128, 128, 150],
+    unknown: [148, 163, 184, 255]
+};
+// Ring geometry as fractions of the icon size.
+const OUTER_RADIUS = 0.47;
+const RING_WIDTH = 0.2;
+// The unknown state is a small dot in the middle of an empty ring.
+const DOT_RADIUS = 0.12;
+// Each pixel is sampled SUPERSAMPLE² times for smooth edges.
+const SUPERSAMPLE = 4;
+// Red at or below the user's low line, green well above it, amber between.
+export const quotaColor = (percent, lowPercent = LOW_QUOTA_PERCENT) => percent <= lowPercent ? COLORS.low : percent > Math.max(AMPLE_PERCENT, lowPercent) ? COLORS.ample : COLORS.some;
+// What covers the point (x, y) in a unit square: the filled arc, the track, the dot or nothing.
+function paint(x, y, percent, fill) {
+    const dx = x - 0.5;
+    const dy = y - 0.5;
+    const distance = Math.hypot(dx, dy);
+    if (percent === null && distance <= DOT_RADIUS)
+        return COLORS.unknown;
+    if (distance > OUTER_RADIUS || distance < OUTER_RADIUS - RING_WIDTH)
+        return null;
+    if (percent === null)
+        return COLORS.track;
+    // Clockwise from twelve o'clock.
+    const turn = (Math.atan2(dx, -dy) / (2 * Math.PI) + 1) % 1;
+    return turn * 100 < percent ? fill : COLORS.track;
+}
+// Straight (non-premultiplied) RGBA pixels, row by row.
+export function ringPixels(size, percent, lowPercent = LOW_QUOTA_PERCENT) {
+    const clamped = percent === null ? null : Math.min(Math.max(percent, 0), 100);
+    const fill = quotaColor(clamped ?? 0, lowPercent);
+    const pixels = Buffer.alloc(size * size * 4);
+    const samples = SUPERSAMPLE * SUPERSAMPLE;
+    for (let py = 0; py < size; py++) {
+        for (let px = 0; px < size; px++) {
+            let [r, g, b, a] = [0, 0, 0, 0];
+            for (let sy = 0; sy < SUPERSAMPLE; sy++) {
+                for (let sx = 0; sx < SUPERSAMPLE; sx++) {
+                    const color = paint((px + (sx + 0.5) / SUPERSAMPLE) / size, (py + (sy + 0.5) / SUPERSAMPLE) / size, clamped, fill);
+                    if (!color)
+                        continue;
+                    // Colors are averaged weighted by their alpha, so edges do not darken.
+                    r += color[0] * color[3];
+                    g += color[1] * color[3];
+                    b += color[2] * color[3];
+                    a += color[3];
+                }
+            }
+            const offset = (py * size + px) * 4;
+            if (a)
+                pixels.set([Math.round(r / a), Math.round(g / a), Math.round(b / a), Math.round(a / samples)], offset);
+        }
+    }
+    return pixels;
+}
+function chunk(type, data) {
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length);
+    const body = Buffer.concat([Buffer.from(type, 'latin1'), data]);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(zlib.crc32(body));
+    return Buffer.concat([length, body, crc]);
+}
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const BIT_DEPTH = 8;
+const COLOR_TYPE_RGBA = 6;
+const FILTER_NONE = 0;
+function encodePng(size, pixels) {
+    const header = Buffer.alloc(13);
+    header.writeUInt32BE(size, 0);
+    header.writeUInt32BE(size, 4);
+    header.set([BIT_DEPTH, COLOR_TYPE_RGBA, 0, 0, 0], 8);
+    // Every row starts with its filter type.
+    const rows = Buffer.alloc(size * (size * 4 + 1));
+    for (let y = 0; y < size; y++) {
+        rows[y * (size * 4 + 1)] = FILTER_NONE;
+        pixels.copy(rows, y * (size * 4 + 1) + 1, y * size * 4, (y + 1) * size * 4);
+    }
+    return Buffer.concat([PNG_SIGNATURE, chunk('IHDR', header), chunk('IDAT', zlib.deflateSync(rows)), chunk('IEND', Buffer.alloc(0))]);
+}
+// The icon at each pixel density the tray may ask for.
+export const ringIcon = (size, percent, lowPercent = LOW_QUOTA_PERCENT) => encodePng(size, ringPixels(size, percent, lowPercent));

package/build/core/updater.d.ts

@@ -0,0 +1,29 @@
+import type { UpdateInstall, UpdateUnsupportedReason } from '../shared/types.ts';
+export interface UpdaterBackend {
+    checkForUpdates(): Promise<{
+        isUpdateAvailable: boolean;
+        updateInfo: {
+            version: string;
+        };
+    } | null>;
+    downloadUpdate(): Promise<unknown>;
+    quitAndInstall(isSilent?: boolean, isForceRunAfter?: boolean): void;
+    on(event: 'download-progress', listener: (progress: {
+        percent: number;
+    }) => void): unknown;
+}
+export interface Installer {
+    state(): UpdateInstall;
+    download(): Promise<void>;
+    install(): void;
+}
+export declare function createInstaller(backend: UpdaterBackend | UpdateUnsupportedReason, onChange: () => void): Installer;
+export interface SupportProbe {
+    packaged: boolean;
+    platform: NodeJS.Platform;
+    execPath: string;
+    exists?: (file: string) => boolean;
+    readText?: (file: string) => string;
+    describeSignature?: (bundle: string) => Promise<string>;
+}
+export declare function updateSupport({ packaged, platform, execPath, exists, readText, describeSignature: describe }: SupportProbe): Promise<UpdateUnsupportedReason | null>;

package/build/core/updater.js

@@ -0,0 +1,88 @@
+// Installing a newer release from inside the app, step by step at the user's request: look for
+// it, download it (verified against the release's checksums by the updater), then restart into
+// it. Nothing downloads or installs by itself. A copy that cannot replace itself (a portable zip,
+// an unsigned macOS app, a development build) keeps the link to the release page.
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { APP_NAME } from "../shared/catalog.js";
+export function createInstaller(backend, onChange) {
+    if (typeof backend === 'string') {
+        const unsupported = { state: 'unsupported', reason: backend };
+        return { state: () => unsupported, download: () => Promise.resolve(), install: () => undefined };
+    }
+    const updater = backend;
+    let current = { state: 'ready' };
+    let running = null;
+    const set = (next) => {
+        current = next;
+        onChange();
+    };
+    updater.on('download-progress', ({ percent }) => {
+        if (current.state === 'downloading' && Number.isFinite(percent))
+            set({ state: 'downloading', percent: Math.max(0, Math.min(100, Math.round(percent))) });
+    });
+    async function run() {
+        set({ state: 'downloading', percent: 0 });
+        try {
+            const result = await updater.checkForUpdates();
+            if (!result?.isUpdateAvailable) {
+                set({ state: 'ready' });
+                return;
+            }
+            await updater.downloadUpdate();
+            set({ state: 'downloaded', version: result.updateInfo.version });
+        }
+        catch {
+            // The updater's own message can carry URLs and paths; the user is told it failed.
+            set({ state: 'failed' });
+        }
+    }
+    return {
+        state: () => structuredClone(current),
+        download() {
+            if (current.state === 'downloaded')
+                return Promise.resolve();
+            running ??= run().finally(() => {
+                running = null;
+            });
+            return running;
+        },
+        install() {
+            if (current.state === 'downloaded')
+                updater.quitAndInstall(false, true);
+        }
+    };
+}
+const execFileAsync = promisify(execFile);
+const describeSignature = async (bundle) => (await execFileAsync('/usr/bin/codesign', ['-dv', '--verbose=2', bundle], { encoding: 'utf8', timeout: 5000 })).stderr;
+// Why this copy cannot update itself, or null when it can. The Windows installer puts its
+// uninstaller beside the app; a portable zip has none. Only a signed build records its publisher
+// in app-update.yml, and only then does the updater check an installer's signature as well as
+// its checksum, so an unsigned copy does not install downloads. macOS only accepts an update to
+// an app signed with a Developer ID.
+export async function updateSupport({ packaged, platform, execPath, exists = fs.existsSync, readText = file => fs.readFileSync(file, 'utf8'), describeSignature: describe = describeSignature }) {
+    if (!packaged)
+        return 'unpackaged';
+    if (platform === 'win32') {
+        const dir = path.dirname(execPath);
+        if (!exists(path.join(dir, `Uninstall ${APP_NAME}.exe`)))
+            return 'portable';
+        let config = '';
+        try {
+            config = readText(path.join(dir, 'resources', 'app-update.yml'));
+        }
+        catch {
+            // No updater configuration: treated like an unsigned copy.
+        }
+        return /^publisherName:/m.test(config) ? null : 'unsigned';
+    }
+    if (platform === 'darwin') {
+        // …/Vibe Usage.app/Contents/MacOS/Vibe Usage
+        const bundle = path.resolve(execPath, '../../..');
+        const signature = await describe(bundle).catch(() => '');
+        return /^Authority=Developer ID Application:/m.test(signature) ? null : 'unsigned';
+    }
+    return 'platform';
+}

package/build/core/updates.d.ts

@@ -0,0 +1,5 @@
+import type { UpdateInfo } from '../shared/types.ts';
+export declare const LATEST_RELEASE_URL = "https://api.github.com/repos/mustafacagri/vibe-usage/releases/latest";
+export declare function isNewer(candidate: string, current: string): boolean;
+export declare function checkForUpdate(currentVersion: string, fetchJson: (url: string) => Promise<unknown>): Promise<UpdateInfo | null>;
+export declare const isReleasePage: (url: unknown) => url is string;

package/build/core/updates.js

@@ -0,0 +1,29 @@
+// Whether a newer release is out: the latest GitHub release of the app's repository against
+// the running version. Nothing is downloaded; the user opens the release page.
+import { APP_REPOSITORY } from "../shared/catalog.js";
+import { isObject } from "./files.js";
+export const LATEST_RELEASE_URL = `https://api.github.com/repos/${APP_REPOSITORY}/releases/latest`;
+const RELEASE_PAGE = `https://github.com/${APP_REPOSITORY}/releases/`;
+const VERSION = /^v?(\d+)\.(\d+)\.(\d+)$/;
+const parts = (version) => VERSION.exec(version)?.slice(1).map(Number) ?? null;
+// Whether `candidate` is a later x.y.z than `current`; false for anything unparsable.
+export function isNewer(candidate, current) {
+    const next = parts(candidate);
+    const now = parts(current);
+    if (!next || !now)
+        return false;
+    const index = next.findIndex((n, i) => n !== now[i]);
+    return index !== -1 && (next[index] ?? 0) > (now[index] ?? 0);
+}
+// The release to tell about, or null when there is none newer. The page must belong to the
+// app's repository: the link is opened in the user's browser.
+export async function checkForUpdate(currentVersion, fetchJson) {
+    const release = await fetchJson(LATEST_RELEASE_URL);
+    if (!isObject(release) || release.draft === true || release.prerelease === true)
+        return null;
+    const { tag_name: tag, html_url: url } = release;
+    if (typeof tag !== 'string' || !isReleasePage(url))
+        return null;
+    return isNewer(tag, currentVersion) ? { version: tag.replace(/^v/, ''), url } : null;
+}
+export const isReleasePage = (url) => typeof url === 'string' && url.startsWith(RELEASE_PAGE);