rms-devremote 3.0.0

package/dist/server/index.d.ts

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

package/dist/server/index.js

@@ -0,0 +1,283 @@
+import { createServer } from 'http';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execFileSync } from 'child_process';
+import express from 'express';
+import { WebSocketServer, WebSocket } from 'ws';
+import { basicAuth } from './auth.js';
+import { createTerminalSession } from './terminal.js';
+import { readConfig, readEnv } from '../services/config.js';
+import { buildFrontendHTML } from './frontend.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ---------------------------------------------------------------------------
+// Server setup
+// ---------------------------------------------------------------------------
+const config = readConfig();
+const PORT = config.ttyd.port;
+const app = express();
+const httpServer = createServer(app);
+// Apply basic auth to all HTTP routes
+app.use(basicAuth);
+// ── Serve xterm.js assets from node_modules ────────────────────────────────
+const pkgRoot = join(__dirname, '..', '..');
+const xtermDir = join(pkgRoot, 'node_modules', '@xterm', 'xterm');
+const fitDir = join(pkgRoot, 'node_modules', '@xterm', 'addon-fit');
+const webLinksDir = join(pkgRoot, 'node_modules', '@xterm', 'addon-web-links');
+app.get('/xterm.css', (_req, res) => {
+    res.setHeader('Content-Type', 'text/css');
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.sendFile(join(xtermDir, 'css', 'xterm.css'));
+});
+app.get('/xterm.js', (_req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.sendFile(join(xtermDir, 'lib', 'xterm.js'));
+});
+app.get('/xterm-addon-fit.js', (_req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.sendFile(join(fitDir, 'lib', 'addon-fit.js'));
+});
+app.get('/xterm-addon-web-links.js', (_req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.sendFile(join(webLinksDir, 'lib', 'addon-web-links.js'));
+});
+// ── PWA assets ─────────────────────────────────────────────────────────────
+app.get('/manifest.json', (_req, res) => {
+    res.json({
+        name: 'devremote',
+        short_name: 'devremote',
+        description: 'Remote terminal access',
+        start_url: '/',
+        display: 'standalone',
+        orientation: 'portrait',
+        background_color: '#000000',
+        theme_color: '#000000',
+        icons: [
+            { src: '/icon.svg', sizes: 'any', type: 'image/svg+xml', purpose: 'any maskable' },
+        ],
+    });
+});
+app.get('/icon.svg', (_req, res) => {
+    res.setHeader('Content-Type', 'image/svg+xml');
+    res.setHeader('Cache-Control', 'public, max-age=86400');
+    res.send(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
+  <rect width="512" height="512" rx="96" fill="#000000"/>
+  <text x="128" y="340" font-family="monospace" font-size="240" font-weight="bold" fill="#00ffaa">&gt;_</text>
+</svg>`);
+});
+app.get('/sw.js', (_req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    res.send(`
+var CACHE = 'devremote-v2';
+var ASSETS = ['/', '/xterm.css', '/xterm.js', '/xterm-addon-fit.js', '/xterm-addon-web-links.js', '/manifest.json', '/icon.svg'];
+
+self.addEventListener('install', function(e) {
+  e.waitUntil(caches.open(CACHE).then(function(c) { return c.addAll(ASSETS); }));
+  self.skipWaiting();
+});
+
+self.addEventListener('activate', function(e) {
+  e.waitUntil(caches.keys().then(function(names) {
+    return Promise.all(names.filter(function(n) { return n !== CACHE; }).map(function(n) { return caches.delete(n); }));
+  }));
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', function(e) {
+  var url = new URL(e.request.url);
+  if (url.pathname === '/ws' || url.pathname === '/health' || url.pathname === '/status') return;
+  if (e.request.method !== 'GET') return;
+  if (url.pathname === '/') {
+    e.respondWith(fetch(e.request).catch(function() { return caches.match(e.request); }));
+  } else {
+    e.respondWith(caches.match(e.request).then(function(r) { return r || fetch(e.request); }));
+  }
+});
+`);
+});
+// ── Main page ──────────────────────────────────────────────────────────────
+app.get('/', (_req, res) => {
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.send(buildFrontendHTML());
+});
+// ── Health / Status ────────────────────────────────────────────────────────
+app.get('/health', (_req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime() });
+});
+app.get('/status', (_req, res) => {
+    // Get tmux current pane path
+    let tmuxPath = '';
+    try {
+        tmuxPath = execFileSync('tmux', ['display-message', '-t', 'devremote', '-p', '#{pane_current_path}'], {
+            encoding: 'utf8', timeout: 3000,
+        }).trim();
+    }
+    catch { /* ignore */ }
+    res.json({
+        tmux: isTmuxAlive(),
+        clientConnected: activeClient !== null && activeClient.readyState === WebSocket.OPEN,
+        cwd: tmuxPath,
+        hostname: process.env.HOSTNAME || '',
+    });
+});
+// ---------------------------------------------------------------------------
+// WebSocket — single terminal session
+// ---------------------------------------------------------------------------
+const wss = new WebSocketServer({ noServer: true });
+let activeClient = null;
+let activeSession = null;
+// Verify basic auth on WebSocket upgrade
+httpServer.on('upgrade', (req, socket, head) => {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Basic ')) {
+        socket.write('HTTP/1.1 401 Unauthorized\r\nWWW-Authenticate: Basic realm="devremote"\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    const encoded = authHeader.slice(6);
+    const decoded = Buffer.from(encoded, 'base64').toString('utf8');
+    const colonIdx = decoded.indexOf(':');
+    if (colonIdx === -1) {
+        socket.destroy();
+        return;
+    }
+    const env = readEnv();
+    const user = decoded.slice(0, colonIdx);
+    const pass = decoded.slice(colonIdx + 1);
+    if (user !== (env.TTYD_USER ?? 'admin') || pass !== (env.TTYD_PASSWORD ?? 'changeme')) {
+        socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    if (req.url !== '/ws') {
+        socket.destroy();
+        return;
+    }
+    // Reject if another client is already connected
+    if (activeClient && activeClient.readyState === WebSocket.OPEN) {
+        socket.write('HTTP/1.1 409 Conflict\r\n\r\n');
+        socket.destroy();
+        return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit('connection', ws, req);
+    });
+});
+wss.on('connection', (ws) => {
+    activeClient = ws;
+    ws.on('message', (raw) => {
+        const msg = typeof raw === 'string' ? raw : raw.toString('utf8');
+        try {
+            const parsed = JSON.parse(msg);
+            if (parsed.type === 'init' && !activeSession) {
+                const cols = parsed.cols || 80;
+                const rows = parsed.rows || 24;
+                activeSession = createTerminalSession(cols, rows);
+                activeSession.onData((data) => {
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'output', data }));
+                    }
+                });
+                activeSession.onExit((_code) => {
+                    if (ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'exit' }));
+                        ws.close();
+                    }
+                    activeSession = null;
+                    activeClient = null;
+                    // Don't shutdown — server stays up for future connections.
+                    // The tmux watcher handles shutdown if tmux truly dies.
+                });
+                return;
+            }
+            if (parsed.type === 'input' && activeSession) {
+                activeSession.write(parsed.data);
+                return;
+            }
+            if (parsed.type === 'resize' && activeSession) {
+                activeSession.resize(parsed.cols, parsed.rows);
+                return;
+            }
+        }
+        catch {
+            // Ignore malformed messages
+        }
+    });
+    ws.on('close', () => {
+        if (activeSession) {
+            activeSession.kill();
+            activeSession = null;
+        }
+        activeClient = null;
+    });
+    ws.on('error', () => {
+        if (activeSession) {
+            activeSession.kill();
+            activeSession = null;
+        }
+        activeClient = null;
+    });
+});
+// ---------------------------------------------------------------------------
+// Watch tmux session — auto-unlink if it dies
+// ---------------------------------------------------------------------------
+function isTmuxAlive() {
+    try {
+        execFileSync('tmux', ['has-session', '-t', 'devremote'], {
+            stdio: 'ignore',
+            timeout: 5000,
+            env: { ...process.env, PATH: process.env.PATH || '/usr/bin:/usr/local/bin:/bin' },
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Only shut down after 3 consecutive failures (avoids false positives)
+let tmuxFailCount = 0;
+const tmuxWatcher = setInterval(() => {
+    if (isTmuxAlive()) {
+        tmuxFailCount = 0;
+    }
+    else {
+        tmuxFailCount++;
+        if (tmuxFailCount >= 3) {
+            console.log('tmux session "devremote" ended — shutting down server');
+            shutdown();
+        }
+    }
+}, 5000);
+// ---------------------------------------------------------------------------
+// Graceful shutdown
+// ---------------------------------------------------------------------------
+function shutdown() {
+    clearInterval(tmuxWatcher);
+    // Close active WebSocket
+    if (activeClient && activeClient.readyState === WebSocket.OPEN) {
+        activeClient.send(JSON.stringify({ type: 'exit' }));
+        activeClient.close();
+    }
+    // Kill PTY
+    if (activeSession) {
+        activeSession.kill();
+        activeSession = null;
+    }
+    // Close server
+    httpServer.close(() => {
+        process.exit(0);
+    });
+    // Force exit after 3s if graceful close hangs
+    setTimeout(() => process.exit(0), 3000);
+}
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+httpServer.listen(PORT, '0.0.0.0', () => {
+    console.log(`devremote server listening on port ${PORT}`);
+});

package/dist/server/terminal.d.ts

@@ -0,0 +1,14 @@
+import type { IPty } from 'node-pty';
+export interface TerminalSession {
+    pty: IPty;
+    onData: (cb: (data: string) => void) => void;
+    onExit: (cb: (code: number) => void) => void;
+    write: (data: string) => void;
+    resize: (cols: number, rows: number) => void;
+    kill: () => void;
+}
+/**
+ * Spawn a PTY that attaches to the devremote tmux session.
+ * If the session doesn't exist, falls back to a plain shell.
+ */
+export declare function createTerminalSession(cols?: number, rows?: number): TerminalSession;

package/dist/server/terminal.js

@@ -0,0 +1,43 @@
+import * as nodePty from 'node-pty';
+/**
+ * Spawn a PTY that attaches to the devremote tmux session.
+ * If the session doesn't exist, falls back to a plain shell.
+ */
+export function createTerminalSession(cols = 80, rows = 24) {
+    const shell = process.env.SHELL || '/bin/bash';
+    const pty = nodePty.spawn('tmux', ['attach-session', '-t', 'devremote'], {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: process.env.HOME || '/',
+        env: process.env,
+    });
+    return {
+        pty,
+        onData(cb) {
+            pty.onData(cb);
+        },
+        onExit(cb) {
+            pty.onExit(({ exitCode }) => cb(exitCode));
+        },
+        write(data) {
+            pty.write(data);
+        },
+        resize(c, r) {
+            try {
+                pty.resize(c, r);
+            }
+            catch {
+                // Ignore resize errors on dead PTY
+            }
+        },
+        kill() {
+            try {
+                pty.kill();
+            }
+            catch {
+                // Already dead
+            }
+        },
+    };
+}

package/dist/services/battery-worker.d.ts

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

package/dist/services/battery-worker.js

@@ -0,0 +1,2 @@
+import { startBatteryWatcher } from './battery.js';
+startBatteryWatcher();

package/dist/services/battery.d.ts

@@ -0,0 +1,27 @@
+export interface BatteryInfo {
+    percent: number;
+    charging: boolean;
+    present: boolean;
+}
+/**
+ * Read current battery state.
+ * On Linux: reads from /sys/class/power_supply/BAT0.
+ * On macOS: parses `pmset -g batt` output.
+ */
+export declare function getBatteryInfo(): BatteryInfo;
+/**
+ * Spawn a sleep-inhibiting process in the background.
+ * Linux: systemd-inhibit. macOS: caffeinate.
+ * Saves the spawned PID to INHIBIT_PID_PATH.
+ */
+export declare function inhibitSleep(): void;
+/**
+ * Release the sleep inhibitor by killing the process whose PID is in INHIBIT_PID_PATH.
+ */
+export declare function releaseSleep(): void;
+/**
+ * Start a battery watcher that periodically checks battery state and sends
+ * ntfy notifications on low battery, unplug, or replug events.
+ * Writes its own PID to BATTERY_PID_PATH.
+ */
+export declare function startBatteryWatcher(): void;

package/dist/services/battery.js

@@ -0,0 +1,152 @@
+import { existsSync, readFileSync } from 'fs';
+import { platform } from 'os';
+import { spawn } from 'child_process';
+import { run } from './shell.js';
+import { writePid, killByPidFile } from './process.js';
+import { INHIBIT_PID_PATH, BATTERY_PID_PATH } from './config.js';
+import { sendNotification } from './ntfy.js';
+// ---------------------------------------------------------------------------
+// Battery info
+// ---------------------------------------------------------------------------
+/**
+ * Read current battery state.
+ * On Linux: reads from /sys/class/power_supply/BAT0.
+ * On macOS: parses `pmset -g batt` output.
+ */
+export function getBatteryInfo() {
+    const os = platform();
+    if (os === 'linux') {
+        return getLinuxBatteryInfo();
+    }
+    if (os === 'darwin') {
+        return getMacBatteryInfo();
+    }
+    // Unsupported platform — return a safe default
+    return { percent: 100, charging: true, present: false };
+}
+function getLinuxBatteryInfo() {
+    const basePath = '/sys/class/power_supply/BAT0';
+    if (!existsSync(basePath)) {
+        return { percent: 100, charging: true, present: false };
+    }
+    const readSys = (file) => {
+        try {
+            return readFileSync(`${basePath}/${file}`, 'utf8').trim();
+        }
+        catch {
+            return '';
+        }
+    };
+    const capacityRaw = readSys('capacity');
+    const statusRaw = readSys('status');
+    const percent = parseInt(capacityRaw, 10);
+    const charging = statusRaw === 'Charging' || statusRaw === 'Full';
+    return {
+        percent: isNaN(percent) ? 100 : percent,
+        charging,
+        present: true,
+    };
+}
+function getMacBatteryInfo() {
+    try {
+        const output = run('pmset', ['-g', 'batt']);
+        // Example line: "Now drawing from 'Battery Power'"
+        const charging = output.includes('AC Power') || output.includes('charging');
+        // Example: "100%;"
+        const percentMatch = output.match(/(\d+)%/);
+        const percent = percentMatch ? parseInt(percentMatch[1], 10) : 100;
+        return { percent, charging, present: true };
+    }
+    catch {
+        return { percent: 100, charging: true, present: false };
+    }
+}
+// ---------------------------------------------------------------------------
+// Sleep inhibit
+// ---------------------------------------------------------------------------
+/**
+ * Spawn a sleep-inhibiting process in the background.
+ * Linux: systemd-inhibit. macOS: caffeinate.
+ * Saves the spawned PID to INHIBIT_PID_PATH.
+ */
+export function inhibitSleep() {
+    const os = platform();
+    let cmd;
+    let args;
+    if (os === 'linux') {
+        cmd = 'systemd-inhibit';
+        args = ['--what=sleep:idle', '--who=rms-devremote', '--why=Remote session active', 'sleep', 'infinity'];
+    }
+    else if (os === 'darwin') {
+        cmd = 'caffeinate';
+        args = ['-i'];
+    }
+    else {
+        throw new Error(`Sleep inhibit not supported on platform: ${os}`);
+    }
+    const child = spawn(cmd, args, {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    if (child.pid === undefined) {
+        throw new Error('Failed to spawn sleep inhibitor: no PID returned');
+    }
+    writePid(INHIBIT_PID_PATH, child.pid);
+}
+/**
+ * Release the sleep inhibitor by killing the process whose PID is in INHIBIT_PID_PATH.
+ */
+export function releaseSleep() {
+    killByPidFile(INHIBIT_PID_PATH);
+}
+// ---------------------------------------------------------------------------
+// Battery watcher
+// ---------------------------------------------------------------------------
+const LOW_BATTERY_THRESHOLD = 20;
+const CRITICAL_BATTERY_THRESHOLD = 10;
+/**
+ * Start a battery watcher that periodically checks battery state and sends
+ * ntfy notifications on low battery, unplug, or replug events.
+ * Writes its own PID to BATTERY_PID_PATH.
+ */
+export function startBatteryWatcher() {
+    writePid(BATTERY_PID_PATH, process.pid);
+    let previousCharging = null;
+    let lowNotified = false;
+    let criticalNotified = false;
+    const check = async () => {
+        const info = getBatteryInfo();
+        if (!info.present)
+            return;
+        // Detect charging state change
+        if (previousCharging !== null && previousCharging !== info.charging) {
+            if (info.charging) {
+                await sendNotification(`Laptop plugged in — battery at ${info.percent}%`, 'low');
+                // Reset low-battery notifications on replug
+                lowNotified = false;
+                criticalNotified = false;
+            }
+            else {
+                await sendNotification(`Laptop unplugged — battery at ${info.percent}%`, 'default');
+            }
+        }
+        previousCharging = info.charging;
+        // Low battery alerts (only when discharging)
+        if (!info.charging) {
+            if (info.percent <= CRITICAL_BATTERY_THRESHOLD && !criticalNotified) {
+                await sendNotification(`CRITICAL: Battery at ${info.percent}% — connect charger now!`, 'urgent');
+                criticalNotified = true;
+            }
+            else if (info.percent <= LOW_BATTERY_THRESHOLD &&
+                !lowNotified &&
+                !criticalNotified) {
+                await sendNotification(`Low battery: ${info.percent}% remaining`, 'high');
+                lowNotified = true;
+            }
+        }
+    };
+    // Run immediately then on interval
+    void check();
+    setInterval(() => { void check(); }, 60_000);
+}

package/dist/services/config.d.ts

@@ -0,0 +1,63 @@
+export declare const DATA_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const ENV_PATH: string;
+export declare const HOOKS_PATH: string;
+export declare const PIN_HASH_PATH: string;
+export declare const DOCKER_COMPOSE_PATH: string;
+export declare const NTFY_CONFIG_PATH: string;
+export declare const NOTIFY_SCRIPT_PATH: string;
+export declare const INHIBIT_PID_PATH: string;
+export declare const BATTERY_PID_PATH: string;
+export interface Config {
+    domains: {
+        terminal: string;
+        notify: string;
+    };
+    ttyd: {
+        port: number;
+    };
+    ntfy: {
+        port: number;
+    };
+    battery: {
+        lowThreshold: number;
+        checkInterval: number;
+    };
+}
+export interface EnvVars {
+    CLOUDFLARE_TUNNEL_TOKEN: string;
+    TERMINAL_DOMAIN: string;
+    NOTIFY_DOMAIN: string;
+    TTYD_USER: string;
+    TTYD_PASSWORD: string;
+    NTFY_TOPIC: string;
+    NTFY_ADMIN_PASSWORD: string;
+    NTFY_PORT: string;
+}
+/**
+ * Ensure the DATA_DIR (~/.rms-devremote/) exists.
+ * Creates it (and any parent directories) if it does not.
+ */
+export declare function ensureDataDir(): void;
+/**
+ * Returns true when setup has been completed (config.json and .env both exist).
+ */
+export declare function isSetupDone(): boolean;
+/**
+ * Read and parse config.json. Throws if the file does not exist.
+ */
+export declare function readConfig(): Config;
+/**
+ * Serialize and write config.json (pretty-printed, 2-space indent).
+ */
+export declare function writeConfig(config: Config): void;
+/**
+ * Read and parse the .env file into an EnvVars object.
+ * Lines that are empty or start with '#' are ignored.
+ */
+export declare function readEnv(): Partial<EnvVars>;
+/**
+ * Serialize an EnvVars object and write it to the .env file.
+ * Each entry is written as KEY="value".
+ */
+export declare function writeEnv(env: Partial<EnvVars>): void;

package/dist/services/config.js

@@ -0,0 +1,84 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+// ---------------------------------------------------------------------------
+// Path constants
+// ---------------------------------------------------------------------------
+export const DATA_DIR = join(homedir(), '.rms-devremote');
+export const CONFIG_PATH = join(DATA_DIR, 'config.json');
+export const ENV_PATH = join(DATA_DIR, '.env');
+export const HOOKS_PATH = join(DATA_DIR, 'hooks.json');
+export const PIN_HASH_PATH = join(DATA_DIR, 'pin.hash');
+export const DOCKER_COMPOSE_PATH = join(DATA_DIR, 'docker-compose.yml');
+export const NTFY_CONFIG_PATH = join(DATA_DIR, 'ntfy', 'server.yml');
+export const NOTIFY_SCRIPT_PATH = join(DATA_DIR, 'notify.sh');
+export const INHIBIT_PID_PATH = join(DATA_DIR, 'inhibit.pid');
+export const BATTERY_PID_PATH = join(DATA_DIR, 'battery.pid');
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Ensure the DATA_DIR (~/.rms-devremote/) exists.
+ * Creates it (and any parent directories) if it does not.
+ */
+export function ensureDataDir() {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+/**
+ * Returns true when setup has been completed (config.json and .env both exist).
+ */
+export function isSetupDone() {
+    return existsSync(CONFIG_PATH) && existsSync(ENV_PATH);
+}
+/**
+ * Read and parse config.json. Throws if the file does not exist.
+ */
+export function readConfig() {
+    const raw = readFileSync(CONFIG_PATH, 'utf8');
+    return JSON.parse(raw);
+}
+/**
+ * Serialize and write config.json (pretty-printed, 2-space indent).
+ */
+export function writeConfig(config) {
+    ensureDataDir();
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
+}
+/**
+ * Read and parse the .env file into an EnvVars object.
+ * Lines that are empty or start with '#' are ignored.
+ */
+export function readEnv() {
+    if (!existsSync(ENV_PATH))
+        return {};
+    const lines = readFileSync(ENV_PATH, 'utf8').split('\n');
+    const result = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        // Strip optional surrounding quotes from the value
+        let value = trimmed.slice(eqIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Serialize an EnvVars object and write it to the .env file.
+ * Each entry is written as KEY="value".
+ */
+export function writeEnv(env) {
+    ensureDataDir();
+    const lines = Object.entries(env).map(([k, v]) => `${k}="${v ?? ''}"`);
+    writeFileSync(ENV_PATH, lines.join('\n') + '\n', 'utf8');
+}