@savepoint/bridge 1.0.0

package/dist/registry.js

@@ -0,0 +1,98 @@
+import Database from 'better-sqlite3';
+import { mkdirSync, readFileSync } from 'fs';
+import { dirname } from 'path';
+export class Registry {
+    db;
+    constructor(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        this.db = new Database(dbPath);
+    }
+    init() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS printers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        model TEXT,
+        host TEXT,
+        port INTEGER,
+        connection_type TEXT NOT NULL,
+        is_default INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS capabilities (
+        model TEXT PRIMARY KEY,
+        manufacturer TEXT NOT NULL,
+        expected_format TEXT NOT NULL,
+        default_port INTEGER,
+        vid INTEGER,
+        pid INTEGER
+      );
+    `);
+    }
+    seedCapabilities(jsonPath) {
+        const caps = JSON.parse(readFileSync(jsonPath, 'utf8'));
+        const upsert = this.db.prepare(`
+      INSERT INTO capabilities (model, manufacturer, expected_format, default_port, vid, pid)
+      VALUES (@model, @manufacturer, @expected_format, @default_port, @vid, @pid)
+      ON CONFLICT(model) DO UPDATE SET
+        manufacturer = excluded.manufacturer,
+        expected_format = excluded.expected_format,
+        default_port = excluded.default_port,
+        vid = excluded.vid,
+        pid = excluded.pid
+    `);
+        const seedAll = this.db.transaction((items) => {
+            for (const c of items)
+                upsert.run(c);
+        });
+        seedAll(caps);
+    }
+    upsertPrinters(printers) {
+        const upsert = this.db.prepare(`
+      INSERT INTO printers (id, name, model, host, port, connection_type, is_default)
+      VALUES (@id, @name, @model, @host, @port, @connectionType, @isDefault)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name, model = excluded.model,
+        host = excluded.host, port = excluded.port,
+        connection_type = excluded.connection_type,
+        is_default = excluded.is_default
+    `);
+        const upsertAll = this.db.transaction((items) => {
+            for (const p of items)
+                upsert.run({ ...p, isDefault: p.isDefault ? 1 : 0 });
+        });
+        upsertAll(printers);
+    }
+    getPrinter(id) {
+        const row = this.db.prepare(`SELECT id, name, model, host, port, connection_type as connectionType, is_default as isDefault
+       FROM printers WHERE id = ?`).get(id);
+        return row ?? null;
+    }
+    getExpectedFormat(printerId) {
+        const printer = this.getPrinter(printerId);
+        if (!printer?.model)
+            return null;
+        const cap = this.db.prepare(`SELECT expected_format FROM capabilities WHERE model = ?`).get(printer.model);
+        return cap?.expected_format ?? null;
+    }
+    validateFormat(printerId, jobFormat) {
+        const printer = this.getPrinter(printerId);
+        if (!printer) {
+            return { code: 'PRINTER_NOT_FOUND', message: `Printer ${printerId} not found in local registry.` };
+        }
+        const expected = this.getExpectedFormat(printerId);
+        if (expected && expected !== jobFormat) {
+            return {
+                code: 'FORMAT_MISMATCH',
+                message: `Printer "${printer.name}" expects ${expected.toUpperCase()} but job format is ${jobFormat.toUpperCase()}. ` +
+                    `Update the printer in SavePoint > Settings > Printers.`,
+            };
+        }
+        return null;
+    }
+    close() { this.db.close(); }
+    listPrinters() {
+        return this.db.prepare(`SELECT id, name, model, host, port, connection_type as connectionType, is_default as isDefault
+       FROM printers
+       ORDER BY is_default DESC, name ASC`).all();
+    }
+}

package/dist/service.d.ts

@@ -0,0 +1,2 @@
+export declare function installService(): Promise<void>;
+export declare function uninstallService(): Promise<void>;

package/dist/service.js

@@ -0,0 +1,114 @@
+import { writeFileSync, mkdirSync, unlinkSync, existsSync } from 'fs';
+import { execFile, execFileSync } from 'child_process';
+import { promisify } from 'util';
+import { homedir, userInfo } from 'os';
+import { join } from 'path';
+import { log } from './logger.js';
+const execFileAsync = promisify(execFile);
+function getBinaryPath() {
+    const locator = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        return execFileSync(locator, ['savepoint-bridge'], { encoding: 'utf8' }).trim().split(/\r?\n/)[0];
+    }
+    catch {
+        return 'savepoint-bridge';
+    }
+}
+async function installMacOS() {
+    const plistDir = join(homedir(), 'Library', 'LaunchAgents');
+    const plistPath = join(plistDir, 'com.savepoint.bridge.plist');
+    const binary = getBinaryPath();
+    const logDir = join(homedir(), '.savepoint-bridge', 'logs');
+    mkdirSync(plistDir, { recursive: true });
+    mkdirSync(logDir, { recursive: true });
+    writeFileSync(plistPath, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>com.savepoint.bridge</string>
+  <key>ProgramArguments</key>
+  <array><string>${binary}</string><string>start</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${logDir}/stdout.log</string>
+  <key>StandardErrorPath</key><string>${logDir}/stderr.log</string>
+</dict>
+</plist>`);
+    // execFile with array args — no shell injection possible
+    await execFileAsync('launchctl', ['load', plistPath]);
+    log.success('LaunchAgent installed');
+}
+async function installLinux() {
+    const unitDir = join(homedir(), '.config', 'systemd', 'user');
+    const unitPath = join(unitDir, 'savepoint-bridge.service');
+    const binary = getBinaryPath();
+    mkdirSync(unitDir, { recursive: true });
+    writeFileSync(unitPath, `[Unit]
+Description=SavePoint Bridge
+After=network-online.target
+
+[Service]
+ExecStart="${binary}" start
+Restart=on-failure
+RestartSec=5s
+
+[Install]
+WantedBy=default.target
+`);
+    await execFileAsync('systemctl', ['--user', 'daemon-reload']);
+    await execFileAsync('systemctl', ['--user', 'enable', '--now', 'savepoint-bridge']);
+    try {
+        const username = userInfo().username;
+        await execFileAsync('loginctl', ['enable-linger', username]);
+        log.info(`loginctl enable-linger applied for ${username} — bridge starts at boot`);
+    }
+    catch {
+        log.warn('Could not enable loginctl linger — bridge may not start at boot on headless systems');
+    }
+    log.success('systemd user service installed');
+}
+async function installWindows() {
+    const binary = getBinaryPath();
+    // schtasks args passed as array — binary path not shell-interpolated
+    await execFileAsync('schtasks', [
+        '/Create', '/F',
+        '/TN', 'SavePoint Bridge',
+        '/TR', `"${binary}" start`,
+        '/SC', 'ONLOGON',
+        '/RL', 'LIMITED',
+    ]);
+    await execFileAsync('schtasks', ['/Run', '/TN', 'SavePoint Bridge']);
+    log.success('Scheduled Task installed');
+}
+export async function installService() {
+    const { platform } = process;
+    if (platform === 'darwin')
+        await installMacOS();
+    else if (platform === 'linux')
+        await installLinux();
+    else if (platform === 'win32')
+        await installWindows();
+    else
+        throw new Error(`Unsupported platform: ${platform}`);
+}
+export async function uninstallService() {
+    const { platform } = process;
+    if (platform === 'darwin') {
+        const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'com.savepoint.bridge.plist');
+        if (existsSync(plistPath)) {
+            await execFileAsync('launchctl', ['unload', plistPath]);
+            unlinkSync(plistPath);
+        }
+    }
+    else if (platform === 'linux') {
+        await execFileAsync('systemctl', ['--user', 'disable', '--now', 'savepoint-bridge']).catch(() => { });
+        const unitPath = join(homedir(), '.config', 'systemd', 'user', 'savepoint-bridge.service');
+        if (existsSync(unitPath))
+            unlinkSync(unitPath);
+        await execFileAsync('systemctl', ['--user', 'daemon-reload']).catch(() => { });
+    }
+    else if (platform === 'win32') {
+        await execFileAsync('schtasks', ['/Delete', '/TN', 'SavePoint Bridge', '/F']).catch(() => { });
+    }
+    log.success('Service uninstalled');
+}

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetup(args: string[]): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,131 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { saveToken } from './token.js';
+import { discoverPrinters } from './discovery.js';
+import { installService } from './service.js';
+import { log } from './logger.js';
+const BASE_URL = process.env.SAVEPOINT_API_URL ?? 'https://api.savepointhq.com';
+const VERSION = '1.0.0';
+function parseFlags(args) {
+    const flags = {};
+    for (const arg of args) {
+        if (arg.startsWith('--')) {
+            const [key, val] = arg.slice(2).split('=');
+            flags[key] = val ?? true;
+        }
+    }
+    return flags;
+}
+export async function runSetup(args) {
+    const flags = parseFlags(args);
+    const nonInteractive = flags['non-interactive'] === true;
+    const noService = flags['no-service'] === true;
+    const tokenFlag = typeof flags['token'] === 'string' ? flags['token'] : null;
+    console.log();
+    console.log(pc.bold('╔══════════════════════════════════════════════════╗'));
+    console.log(pc.bold('║           SavePoint Bridge  v' + VERSION.padEnd(22) + '║'));
+    console.log(pc.bold('║     Local hardware connector for SavePoint       ║'));
+    console.log(pc.bold('╚══════════════════════════════════════════════════╝'));
+    console.log(`
+What this does:
+  - Connects your local printers to SavePoint
+  - Runs quietly in the background -- starts automatically on login
+  - Communicates outbound only to api.savepointhq.com
+    (no ports are opened on your network or firewall)
+
+What it stores on this computer:
+  - Your agent token (stored in your OS keychain -- not a plain text file)
+  - A local printer registry (SQLite in your app data folder)
+  - A rolling log file (last 7 days, local only)
+
+You can revoke access at any time from:
+  SavePoint > Settings > Bridge > Revoke
+`);
+    if (!nonInteractive) {
+        const proceed = await p.confirm({ message: 'Continue with setup?' });
+        if (p.isCancel(proceed) || !proceed) {
+            console.log('Setup cancelled.');
+            return;
+        }
+    }
+    p.intro(pc.bold('Step 1 of 3 -- Agent Token'));
+    let token;
+    if (tokenFlag) {
+        token = tokenFlag;
+        log.info(`Using token from --token flag (prefix: ${token.slice(0, 8)}...)`);
+    }
+    else {
+        const input = await p.text({
+            message: 'Open SavePoint > Settings > Bridge > Add Bridge and paste your token:',
+            placeholder: 'Paste token here...',
+            validate: v => v.length < 32 ? 'Token looks too short -- check you copied the full value' : undefined,
+        });
+        if (p.isCancel(input)) {
+            console.log('Setup cancelled.');
+            return;
+        }
+        token = input;
+    }
+    const spinner = p.spinner();
+    spinner.start('Verifying token...');
+    try {
+        const res = await fetch(`${BASE_URL}/api/agents/heartbeat`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'X-Agent-Version': VERSION,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ version: VERSION }),
+        });
+        if (!res.ok) {
+            spinner.stop(pc.red('Token verification failed -- check the token and try again'));
+            process.exit(1);
+        }
+        spinner.stop(pc.green('Token verified'));
+    }
+    catch (e) {
+        spinner.stop(pc.red(`Could not reach ${BASE_URL}`));
+        if (e instanceof Error && e.message.toLowerCase().includes('certificate')) {
+            console.log(pc.yellow('\nSSL error -- if your network uses an SSL proxy, set:'));
+            console.log(pc.yellow('  NODE_EXTRA_CA_CERTS=/path/to/proxy-ca.crt savepoint-bridge setup\n'));
+        }
+        process.exit(1);
+    }
+    await saveToken(token);
+    p.intro(pc.bold('Step 2 of 3 -- Printers'));
+    const discoverSpinner = p.spinner();
+    discoverSpinner.start('Scanning for printers on your network and local CUPS queues...');
+    const printers = await discoverPrinters();
+    if (printers.length === 0) {
+        discoverSpinner.stop('No printers found automatically');
+        console.log(pc.dim('  Add printers manually in SavePoint > Settings > Printers'));
+    }
+    else {
+        discoverSpinner.stop(`Found ${printers.length} printer${printers.length > 1 ? 's' : ''}:`);
+        for (const pr of printers) {
+            const loc = pr.host ? `${pr.host}:${pr.port}` : pr.name;
+            console.log(pc.green('    v'), pr.name, pc.dim(`(${loc})`));
+        }
+    }
+    if (!noService) {
+        p.intro(pc.bold('Step 3 of 3 -- Background Service'));
+        const svcSpinner = p.spinner();
+        svcSpinner.start('Installing as a background service...');
+        try {
+            await installService();
+            svcSpinner.stop(pc.green('Service installed and started'));
+        }
+        catch (e) {
+            svcSpinner.stop(pc.yellow('Service install failed -- run manually with: savepoint-bridge start'));
+            log.warn('Service install error', e);
+        }
+    }
+    p.outro(pc.bold(pc.green('All done. SavePoint Bridge is running.')));
+    console.log(`
+  Next steps:
+    - Print a test label from SavePoint > Settings > Printers
+    - Run  ${pc.cyan('savepoint-bridge status')}  to check anytime
+    - Run  ${pc.cyan('savepoint-bridge logs')}    to see recent activity
+`);
+}

package/dist/status.d.ts

@@ -0,0 +1 @@
+export declare function showStatus(): Promise<void>;

package/dist/status.js

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { homedir } from 'os';
+import { join } from 'path';
+import { loadToken } from './token.js';
+import { DATA_PATH } from './logger.js';
+import { Registry } from './registry.js';
+const execFileAsync = promisify(execFile);
+const REGISTRY_PATH = join(DATA_PATH, 'registry.db');
+function getServiceArtifactPath() {
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'LaunchAgents', 'com.savepoint.bridge.plist');
+    }
+    if (process.platform === 'linux') {
+        return join(homedir(), '.config', 'systemd', 'user', 'savepoint-bridge.service');
+    }
+    return null;
+}
+async function getServiceState() {
+    if (process.platform === 'darwin') {
+        const path = getServiceArtifactPath();
+        const installed = existsSync(path);
+        if (!installed) {
+            return { installed: false, running: false, detail: 'LaunchAgent not installed' };
+        }
+        try {
+            await execFileAsync('launchctl', ['list', 'com.savepoint.bridge']);
+            return { installed: true, running: true, detail: 'launchd service loaded' };
+        }
+        catch {
+            return { installed: true, running: false, detail: 'LaunchAgent installed but not loaded' };
+        }
+    }
+    if (process.platform === 'linux') {
+        const path = getServiceArtifactPath();
+        const installed = existsSync(path);
+        if (!installed) {
+            return { installed: false, running: false, detail: 'systemd user unit not installed' };
+        }
+        try {
+            const { stdout } = await execFileAsync('systemctl', ['--user', 'is-active', 'savepoint-bridge']);
+            const running = stdout.trim() === 'active';
+            return {
+                installed: true,
+                running,
+                detail: running ? 'systemd user service active' : `systemd state: ${stdout.trim() || 'inactive'}`,
+            };
+        }
+        catch {
+            return { installed: true, running: false, detail: 'systemd user service inactive' };
+        }
+    }
+    if (process.platform === 'win32') {
+        try {
+            const { stdout } = await execFileAsync('schtasks', ['/Query', '/TN', 'SavePoint Bridge']);
+            return {
+                installed: true,
+                running: /SavePoint Bridge/i.test(stdout),
+                detail: 'Scheduled Task is registered',
+            };
+        }
+        catch {
+            return { installed: false, running: false, detail: 'Scheduled Task not installed' };
+        }
+    }
+    return { installed: false, running: false, detail: `Unsupported platform: ${process.platform}` };
+}
+function readPrinterSummary() {
+    if (!existsSync(REGISTRY_PATH)) {
+        return { printerCount: 0, defaultPrinter: null };
+    }
+    const registry = new Registry(REGISTRY_PATH);
+    try {
+        const printers = registry.listPrinters();
+        const defaultPrinter = printers.find((printer) => printer.isDefault)?.name ?? null;
+        return { printerCount: printers.length, defaultPrinter };
+    }
+    finally {
+        registry.close();
+    }
+}
+function readRecentErrorCount() {
+    const logDir = join(DATA_PATH, 'logs');
+    if (!existsSync(logDir))
+        return 0;
+    try {
+        const file = join(logDir, `${new Date().toISOString().slice(0, 10)}.log`);
+        if (!existsSync(file))
+            return 0;
+        return readFileSync(file, 'utf8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line))
+            .filter((entry) => entry.level === 'error')
+            .length;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function showStatus() {
+    const [service, token] = await Promise.all([getServiceState(), loadToken()]);
+    const { printerCount, defaultPrinter } = readPrinterSummary();
+    const errorCount = readRecentErrorCount();
+    const tokenPrefix = token ? `${token.slice(0, 10)}...` : null;
+    console.log('SavePoint Bridge status');
+    console.log(`  service: ${service.running ? 'running' : service.installed ? 'installed' : 'not installed'}`);
+    console.log(`  detail: ${service.detail}`);
+    console.log(`  token: ${tokenPrefix ?? 'missing'}`);
+    console.log(`  local printers: ${printerCount}`);
+    console.log(`  default printer: ${defaultPrinter ?? 'none'}`);
+    console.log(`  today errors: ${errorCount}`);
+}

package/dist/token.d.ts

@@ -0,0 +1,3 @@
+export declare function saveToken(token: string): Promise<void>;
+export declare function loadToken(): Promise<string | null>;
+export declare function clearToken(): Promise<void>;

package/dist/token.js

@@ -0,0 +1,75 @@
+import { createCipheriv, createDecipheriv, randomBytes, createHash } from 'crypto';
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { DATA_PATH, log } from './logger.js';
+const SERVICE = 'savepoint-bridge';
+const ACCOUNT = 'agent-token';
+const FALLBACK_PATH = join(DATA_PATH, '.token');
+/** Derives a machine-stable AES-256 key from the home directory path */
+function deriveFallbackKey() {
+    const seed = `${process.env.HOME ?? process.env.USERPROFILE ?? ''}:${process.platform}`;
+    return createHash('sha256').update(seed).digest();
+}
+async function trykeytar() {
+    try {
+        return await import('@postman/node-keytar');
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveToken(token) {
+    const keytar = await trykeytar();
+    if (keytar) {
+        try {
+            await keytar.setPassword(SERVICE, ACCOUNT, token);
+            return;
+        }
+        catch (e) {
+            log.warn('OS keychain unavailable — using encrypted file fallback', e);
+        }
+    }
+    mkdirSync(DATA_PATH, { recursive: true });
+    const key = deriveFallbackKey();
+    const iv = randomBytes(16);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(token, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    writeFileSync(FALLBACK_PATH, Buffer.concat([iv, tag, encrypted]), { mode: 0o600 });
+    log.warn('Token stored in encrypted local file. Install gnome-keyring for better security.');
+}
+export async function loadToken() {
+    const keytar = await trykeytar();
+    if (keytar) {
+        try {
+            return await keytar.getPassword(SERVICE, ACCOUNT);
+        }
+        catch { /* fall through */ }
+    }
+    try {
+        const raw = readFileSync(FALLBACK_PATH);
+        const key = deriveFallbackKey();
+        const iv = raw.subarray(0, 16);
+        const tag = raw.subarray(16, 32);
+        const encrypted = raw.subarray(32);
+        const decipher = createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        return decipher.update(encrypted) + decipher.final('utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function clearToken() {
+    const keytar = await trykeytar();
+    if (keytar) {
+        try {
+            await keytar.deletePassword(SERVICE, ACCOUNT);
+        }
+        catch { /* ignore */ }
+    }
+    try {
+        unlinkSync(FALLBACK_PATH);
+    }
+    catch { /* ignore */ }
+}

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+export type JobType = 'label' | 'receipt' | 'document' | 'test';
+export type JobStatus = 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled';
+export type ConnectionType = 'network' | 'usb' | 'system';
+export interface JobResult {
+    code?: string;
+    message?: string;
+    attempts?: number;
+    http_status?: number;
+    [key: string]: unknown;
+}
+export interface PrintJobMetadata {
+    format?: 'zpl' | 'esc-p' | 'pdf' | 'raw';
+    copies?: number;
+    [key: string]: unknown;
+}
+export interface PrintJob {
+    id: string;
+    tenant_id: string;
+    printer_id: string | null;
+    job_type: JobType;
+    content_url: string | null;
+    metadata: PrintJobMetadata;
+    status: JobStatus;
+    claimed_by: string | null;
+    claimed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface Printer {
+    id: string;
+    name: string;
+    model: string | null;
+    host: string | null;
+    port: number | null;
+    connectionType: ConnectionType;
+    protocol: string | null;
+    isDefault: boolean;
+}
+export interface PrinterCapability {
+    model: string;
+    manufacturer: string;
+    expected_format: 'zpl' | 'esc-p' | 'pdf' | 'raw';
+    default_port: number;
+    connection_types: ConnectionType[];
+    vid?: number;
+    pid?: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@savepoint/bridge",
+  "version": "1.0.0",
+  "private": false,
+  "description": "SavePoint Bridge hardware daemon",
+  "keywords": [
+    "savepoint",
+    "pos",
+    "bridge",
+    "hardware",
+    "daemon"
+  ],
+  "homepage": "https://savepointhq.com",
+  "bugs": {
+    "url": "https://github.com/doublexl-digital/savepoint-hq/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/doublexl-digital/savepoint-hq.git",
+    "directory": "apps/bridge"
+  },
+  "license": "MIT",
+  "author": "SavePoint",
+  "type": "module",
+  "main": "dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": {
+    "savepoint-bridge": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "capabilities",
+    "LICENSE",
+    "README.md",
+    "USAGE.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "check:release": "npm run type-check && npm run test",
+    "prepublishOnly": "npm run build && npm run check:release",
+    "build:binaries": "electron-builder -mwl"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "@postman/node-keytar": "^7.9.0",
+    "better-sqlite3": "^12.8.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^20.10.0",
+    "electron": "^41.0.4",
+    "electron-builder": "^26.8.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "preferGlobal": true
+}