@ciphore/radiocli 0.2.1 → 0.2.3

package/dist/alarms/active-session.js

@@ -0,0 +1,183 @@
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createServer, request } from 'node:http';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export async function startActiveAlarmSession(initial, handlers) {
+    const filePath = handlers.filePath ?? defaultActiveAlarmPath(initial.alarmId, initial.scheduledAt);
+    const token = randomBytes(32).toString('hex');
+    let status = { ...initial };
+    let terminalStarted = false;
+    const server = createServer(async (req, res) => {
+        res.setHeader('content-type', 'application/json');
+        if (req.headers.authorization !== `Bearer ${token}`) {
+            res.statusCode = 401;
+            res.end('{}');
+            return;
+        }
+        try {
+            if (req.method === 'GET' && req.url === '/status') {
+                res.end(JSON.stringify(status));
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/dismiss') {
+                if (terminalStarted)
+                    throw new Error('A terminal alarm action is already in progress.');
+                terminalStarted = true;
+                try {
+                    await handlers.onDismiss();
+                }
+                catch (error) {
+                    terminalStarted = false;
+                    throw error;
+                }
+                res.end('{}');
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/handoff') {
+                if (terminalStarted)
+                    throw new Error('A terminal alarm action is already in progress.');
+                if (!handlers.onHandoff)
+                    throw new Error('Interactive playback handoff is unavailable for this alarm session.');
+                terminalStarted = true;
+                try {
+                    await handlers.onHandoff();
+                }
+                catch (error) {
+                    terminalStarted = false;
+                    throw error;
+                }
+                res.end('{}');
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/keep-playing') {
+                if (terminalStarted)
+                    throw new Error('The alarm is already stopping.');
+                await handlers.onKeepPlaying();
+                res.end('{}');
+                return;
+            }
+            if (req.method === 'POST' && req.url === '/snooze') {
+                if (terminalStarted)
+                    throw new Error('A terminal alarm action is already in progress.');
+                const body = await readBody(req);
+                const minutes = Number(JSON.parse(body).minutes);
+                if (!Number.isInteger(minutes) || minutes < 1 || minutes > 1440)
+                    throw new Error('Snooze must be 1–1440 minutes.');
+                if (terminalStarted)
+                    throw new Error('A terminal alarm action is already in progress.');
+                terminalStarted = true;
+                try {
+                    await handlers.onSnooze(minutes);
+                }
+                catch (error) {
+                    terminalStarted = false;
+                    throw error;
+                }
+                res.end('{}');
+                return;
+            }
+            res.statusCode = 404;
+            res.end('{}');
+        }
+        catch (error) {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'request failed' }));
+        }
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', () => resolve()); });
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Unable to create alarm control endpoint.');
+    const discovery = { version: 1, host: '127.0.0.1', port: address.port, token, pid: process.pid, alarmId: initial.alarmId, createdAt: new Date().toISOString() };
+    const temp = `${filePath}.tmp-${process.pid}-${randomBytes(6).toString('hex')}`;
+    try {
+        mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+        writeFileSync(temp, `${JSON.stringify(discovery)}\n`, { mode: 0o600 });
+        renameSync(temp, filePath);
+        if (process.platform !== 'win32')
+            chmodSync(filePath, 0o600);
+    }
+    catch (error) {
+        rmSync(temp, { force: true });
+        removeDiscoveryIfOwned(filePath, discovery);
+        await new Promise(resolve => server.close(() => resolve()));
+        throw error;
+    }
+    return { update(change) { status = { ...status, ...change }; }, async close() { await new Promise(resolve => server.close(() => resolve())); removeDiscoveryIfOwned(filePath, discovery); } };
+}
+export async function connectActiveAlarm(filePath) {
+    if (!filePath) {
+        const clients = await connectActiveAlarms();
+        return clients[0] ?? null;
+    }
+    if (!existsSync(filePath))
+        return null;
+    let discovery;
+    try {
+        discovery = JSON.parse(readFileSync(filePath, 'utf8'));
+        if (discovery.version !== 1 || discovery.host !== '127.0.0.1' || !Number.isInteger(discovery.port) || !discovery.token)
+            throw new Error('invalid');
+    }
+    catch {
+        return null;
+    }
+    const call = async (method, path, body) => { const payload = body === undefined ? '' : JSON.stringify(body); return new Promise((resolve, reject) => { const req = request({ host: '127.0.0.1', port: discovery.port, path, method, headers: { authorization: `Bearer ${discovery.token}`, 'content-type': 'application/json', 'content-length': Buffer.byteLength(payload) } }, res => { let text = ''; res.on('data', value => text += String(value)); res.on('end', () => res.statusCode && res.statusCode < 300 ? resolve(text ? JSON.parse(text) : {}) : reject(new Error('Alarm control request failed.'))); }); req.once('error', reject); req.setTimeout(1000, () => req.destroy(new Error('Alarm control request timed out.'))); req.end(payload); }); };
+    try {
+        await call('GET', '/status');
+    }
+    catch {
+        if (!processAlive(discovery.pid) || discoveryAgeMs(filePath, discovery) > 5 * 60_000)
+            removeDiscoveryIfOwned(filePath, discovery);
+        return null;
+    }
+    return { status: async () => await call('GET', '/status'), dismiss: async () => { await call('POST', '/dismiss'); }, snooze: async (minutes) => { await call('POST', '/snooze', { minutes }); }, keepPlaying: async () => { await call('POST', '/keep-playing'); }, handoff: async () => { await call('POST', '/handoff'); } };
+}
+export async function connectActiveAlarms(directory = defaultActiveAlarmDirectory()) { if (!existsSync(directory))
+    return []; const paths = readdirSync(directory).filter(name => name.endsWith('.json')).map(name => join(directory, name)); const clients = await Promise.all(paths.map(path => connectActiveAlarm(path))); return clients.filter((client) => Boolean(client)); }
+function defaultActiveAlarmDirectory() { if (process.env.RADIOCLI_HOME)
+    return join(process.env.RADIOCLI_HOME, 'runtime', 'active-alarms'); if (process.platform === 'darwin')
+    return join(homedir(), 'Library', 'Application Support', 'radiocli', 'runtime', 'active-alarms'); if (process.platform === 'win32')
+    return join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'RadioCLI', 'runtime', 'active-alarms'); return join(process.env.XDG_RUNTIME_DIR ?? join(homedir(), '.local', 'state'), 'radiocli', 'active-alarms'); }
+function defaultActiveAlarmPath(alarmId = 'active', occurrenceAt = 'current') { return join(defaultActiveAlarmDirectory(), `${Buffer.from(`${alarmId}\0${occurrenceAt}`).toString('base64url')}.json`); }
+function readBody(req) { return new Promise((resolve, reject) => { let body = ''; req.on('data', value => { body += String(value); if (body.length > 4096)
+    req.destroy(new Error('Request too large.')); }); req.on('end', () => resolve(body)); req.on('error', reject); }); }
+function removeDiscoveryIfOwned(filePath, owner) { let current; try {
+    current = JSON.parse(readFileSync(filePath, 'utf8'));
+}
+catch {
+    return;
+} if (!sameDiscovery(current, owner))
+    return; const quarantine = `${filePath}.closing-${process.pid}-${randomBytes(6).toString('hex')}`; try {
+    renameSync(filePath, quarantine);
+    const moved = JSON.parse(readFileSync(quarantine, 'utf8'));
+    if (sameDiscovery(moved, owner)) {
+        rmSync(quarantine, { force: true });
+        return;
+    }
+    if (!existsSync(filePath))
+        renameSync(quarantine, filePath);
+}
+catch {
+    if (existsSync(quarantine) && !existsSync(filePath))
+        try {
+            renameSync(quarantine, filePath);
+        }
+        catch { }
+} }
+function sameDiscovery(left, right) { return left.version === right.version && left.host === right.host && left.port === right.port && left.token === right.token && left.pid === right.pid && left.alarmId === right.alarmId; }
+function processAlive(pid) { if (!Number.isInteger(pid) || pid <= 0)
+    return false; try {
+    process.kill(pid, 0);
+    return true;
+}
+catch (error) {
+    return error.code === 'EPERM';
+} }
+function discoveryAgeMs(filePath, discovery) { const created = discovery.createdAt ? Date.parse(discovery.createdAt) : Number.NaN; if (Number.isFinite(created))
+    return Math.max(0, Date.now() - created); try {
+    return Math.max(0, Date.now() - statSync(filePath).mtimeMs);
+}
+catch {
+    return 0;
+} }

package/dist/alarms/cli.js

@@ -0,0 +1,312 @@
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { JsonLibraryStore, stationKey } from '../storage/store.js';
+import { ProviderManager } from '../providers/provider-manager.js';
+import { PlayerController } from '../player/player-controller.js';
+import { detectPlaybackBackends } from '../player/backend-install.js';
+import { canonicalizeAlarmTime, canonicalizeIsoWeekdays, canonicalizeTimeZone, nextOccurrenceForAlarm } from './schedule.js';
+import { createSchedulerService, shouldRunLaunchdOccurrence } from './scheduler.js';
+import { connectActiveAlarms } from './active-session.js';
+import { createPowerInhibitor } from './inhibitor.js';
+import { acquireOccurrenceLock, defaultRunnerUtilities, runAlarm } from './runner.js';
+import { AlarmGuardService, runAlarmGuard } from './guard.js';
+import { AlarmPowerGuardStore } from './power-guard-store.js';
+import { openAlarmControls } from './terminal-launcher.js';
+import { hasLiveTui } from './tui-presence.js';
+import { createSystemVolumeController } from './system-volume.js';
+import { connectRadioSession } from '../agent/session.js';
+export async function runAlarmCommand(args, dependencies = {}) {
+    const store = dependencies.store ?? new JsonLibraryStore();
+    const scheduler = dependencies.scheduler ?? createSchedulerService();
+    const [sub = 'list', ...rest] = args;
+    if (sub === 'list') {
+        const json = rest.includes('--json');
+        const alarms = store.listAlarms();
+        if (json)
+            console.log(JSON.stringify(alarms, null, 2));
+        else if (!alarms.length)
+            console.log('No alarms.');
+        else
+            for (const alarm of alarms)
+                console.log(formatAlarm(alarm));
+        return;
+    }
+    if (sub === 'show') {
+        const alarm = requireAlarm(store, rest[0]);
+        console.log(JSON.stringify({ ...alarm, nextOccurrence: nextOccurrenceForAlarm(alarm, new Date())?.toISOString() ?? null }, null, 2));
+        return;
+    }
+    if (sub === 'add') {
+        const parsed = parseOptions(rest);
+        if (parsed.positionals.length)
+            throw new Error('Alarm add does not accept positional arguments.');
+        const station = resolveStation(store, required(parsed, 'station'));
+        const input = createInput(parsed, station);
+        if (parsed.values.has('fallback'))
+            input.playback.fallbackStation = resolveStation(store, String(parsed.values.get('fallback')));
+        const alarm = store.addAlarm(input);
+        await syncSaved(scheduler, alarm);
+        if (alarm.reliability.keepAwakeUntilAlarm)
+            await reconcileAlarmGuard(alarm);
+        console.log(`alarm=${alarm.id}`);
+        return;
+    }
+    if (sub === 'edit') {
+        const parsed = parseOptions(rest);
+        if (parsed.positionals.length !== 1)
+            throw new Error('Usage: radiocli alarm edit <id> [options]');
+        const id = parsed.positionals[0];
+        const alarm = requireAlarm(store, id);
+        const updated = store.updateAlarm(alarm.id, updatesFromOptions(parsed, store, alarm));
+        await syncSaved(scheduler, updated);
+        if (updated.reliability.keepAwakeUntilAlarm || parsed.values.has('no-guard'))
+            await reconcileAlarmGuard(updated);
+        console.log(`updated=${updated.id}`);
+        return;
+    }
+    if (sub === 'enable' || sub === 'disable') {
+        const alarm = store.toggleAlarm(requiredPos(rest, 0), sub === 'enable');
+        await syncSaved(scheduler, alarm);
+        await reconcileAlarmGuard(alarm);
+        console.log(`${sub}d=${alarm.id}`);
+        return;
+    }
+    if (sub === 'remove') {
+        const id = requiredPos(rest, 0);
+        requireAlarm(store, id);
+        await scheduler.remove(id);
+        if (!store.removeAlarm(id))
+            throw new Error(`Alarm not found: ${id}`);
+        console.log(`removed=${id}`);
+        return;
+    }
+    if (sub === 'sync') {
+        const results = await scheduler.syncAll(store.listAlarms());
+        for (const item of results)
+            console.log(`${item.id}=${item.error ? `degraded ${item.error}` : item.occurrence?.toISOString() ?? 'disabled'}`);
+        if (results.some(item => item.error))
+            process.exitCode = 1;
+        return;
+    }
+    if (sub === 'doctor') {
+        const guards = await new AlarmGuardService(new AlarmPowerGuardStore()).status();
+        const active = await statusesOf(await connectActiveAlarms());
+        const powerCapability = createPowerInhibitor().status();
+        const schedulerStatus = await scheduler.runtimeStatus(store.listAlarms());
+        const report = { scheduler: schedulerStatus, power: { ...powerCapability, active: guards.active || runnerPowerActive(active, schedulerStatus.entries) }, guards, active };
+        if (rest.includes('--json'))
+            console.log(JSON.stringify(report, null, 2));
+        else {
+            console.log(`scheduler=${report.scheduler.capabilities.supported ? 'ready' : 'unsupported'} ${report.scheduler.capabilities.message}`);
+            console.log(`scheduler_degraded=${report.scheduler.entries.filter(item => !item.healthy).length}`);
+            console.log(`power_guard=${report.power.supported ? 'ready' : 'unsupported'} ${report.power.message}`);
+            console.log(`guards=${guards.guards.length}`);
+            console.log(`active=${active.length}`);
+        }
+        return;
+    }
+    if (sub === 'status') {
+        const active = await selectedActiveStatuses(rest);
+        const guards = await new AlarmGuardService(new AlarmPowerGuardStore()).status();
+        const powerCapability = createPowerInhibitor().status();
+        const schedulerStatus = await scheduler.runtimeStatus(store.listAlarms());
+        console.log(JSON.stringify({ active, scheduler: schedulerStatus, guards, power: { ...powerCapability, active: guards.active || runnerPowerActive(active, schedulerStatus.entries) } }, null, 2));
+        return;
+    }
+    if (sub === 'dismiss') {
+        const active = await requireActive(rest);
+        await active.dismiss();
+        console.log('dismissed=yes');
+        return;
+    }
+    if (sub === 'snooze') {
+        const minutes = integer(requiredPos(rest, 0), 'snooze minutes', 1, 1440);
+        const active = await requireActive(rest.slice(1));
+        await active.snooze(minutes);
+        console.log(`snoozed=${minutes}`);
+        return;
+    }
+    if (sub === 'keep-playing') {
+        const active = await requireActive(rest);
+        await active.keepPlaying();
+        console.log('keep_playing=yes');
+        return;
+    }
+    if (sub === 'guard') {
+        const action = rest[0] ?? 'status';
+        const guards = new AlarmGuardService(new AlarmPowerGuardStore());
+        if (action === 'start') {
+            const alarm = requireAlarm(store, rest[1]);
+            const result = await guards.start(alarm);
+            console.log(`guard=${result.occurrenceAt}`);
+        }
+        else if (action === 'stop')
+            console.log(`stopped=${await guards.stop(rest[1]) ? 'yes' : 'no'}`);
+        else if (action === 'status')
+            console.log(JSON.stringify(await guards.status(), null, 2));
+        else
+            throw new Error('Usage: radiocli alarm guard start <id>|stop [id]|status');
+        return;
+    }
+    if (sub === 'test') {
+        const alarm = requireAlarm(store, rest[0]);
+        await testAlarm(alarm, store);
+        console.log('test=complete');
+        return;
+    }
+    if (sub === 'internal-run') {
+        const id = requiredPos(rest, 0);
+        const at = requiredPos(rest, 1);
+        await runAlarm(id, at, createRuntimeDeps(store, scheduler, id));
+        return;
+    }
+    if (sub === 'internal-launchd') {
+        const id = requiredPos(rest, 0);
+        const at = requiredPos(rest, 1);
+        if (!shouldRunLaunchdOccurrence(at, new Date()))
+            return;
+        await runAlarm(id, at, createRuntimeDeps(store, scheduler, id));
+        return;
+    }
+    if (sub === 'internal-guard-run') {
+        await runAlarmGuard(requiredPos(rest, 0), requiredPos(rest, 1), createPowerInhibitor(), new AlarmPowerGuardStore(), () => new Date(), defaultRunnerUtilities.wait, rest[2], rest[3]);
+        return;
+    }
+    throw new Error(alarmUsage());
+}
+function createRuntimeDeps(store, scheduler, alarmId) { const providers = new ProviderManager(); const alarm = store.getAlarm(alarmId); const detected = detectPlaybackBackends(); const settings = alarm ? alarmRuntimeSettings(store.snapshot().settings, alarm, detected) : { ...store.snapshot().settings, preferredBackend: 'auto', preferredAirPlayDevice: undefined }; const player = new PlayerController(() => settings); player.refreshDetectedBackends(); const cliPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'cli.js'); return { now: () => new Date(), store, providers, player, scheduler, inhibitor: createPowerInhibitor(), systemVolume: createSystemVolumeController(), preemptInteractivePlayback: async () => { const client = await connectRadioSession(); if (!client)
+        return; const result = await client.call({ type: 'alarm-preempt' }); if (!result.ok)
+        throw new Error(result.message); }, acquireLock: acquireOccurrenceLock, createSession: defaultRunnerUtilities.createSession, openControls: () => openAlarmControls({ nodePath: process.execPath, cliPath, hasLiveTui }), wait: defaultRunnerUtilities.wait, subscribeSignals: defaultRunnerUtilities.subscribeSignals, health: scheduler.health }; }
+export function alarmRuntimeSettings(settings, alarm, backends) { const mpvFade = alarm.playback.fadeSeconds > 0 && backends.includes('mpv'); return { ...settings, volume: mpvFade ? 0 : alarm.playback.volume, preferredBackend: mpvFade ? 'mpv' : 'auto', preferredAirPlayDevice: undefined }; }
+async function testAlarm(alarm, store) {
+    const scheduledAt = new Date(Math.floor(Date.now() / 60_000) * 60_000);
+    const deadline = Date.now() + 10_000;
+    const preview = { ...alarm, id: `test-${process.pid}`, enabled: true, schedule: { type: 'once', at: scheduledAt.toISOString() }, playback: { ...alarm.playback, fadeSeconds: Math.min(alarm.playback.fadeSeconds, 8), stopAfterMinutes: 1 }, reliability: { ...alarm.reliability, missedRunGraceMinutes: Math.max(1, alarm.reliability.missedRunGraceMinutes) } };
+    const settings = { ...alarmRuntimeSettings(store.snapshot().settings, preview, detectPlaybackBackends()), tuneTimeoutSeconds: 3 };
+    const player = new PlayerController(() => settings);
+    player.refreshDetectedBackends();
+    const providers = new ProviderManager();
+    const boundedProviders = { resolve: (station) => Promise.race([providers.resolve(station), rejectAt(deadline - 3000, 'Alarm preview station resolution timed out.')]) };
+    let interrupt = () => { };
+    const noOp = () => ({});
+    const runner = runAlarm(preview.id, scheduledAt.toISOString(), { now: () => new Date(), store: { getAlarm: () => preview, recordAlarmOutcome: noOp, toggleAlarm: noOp, snoozeAlarm: noOp, addRecent: noOp, startListeningSession: noOp, checkpointActiveListeningSession: noOp, finishActiveListeningSession: noOp }, providers: boundedProviders, player, scheduler: { sync: async () => null }, inhibitor: createPowerInhibitor(), acquireLock: () => () => { }, createSession: defaultRunnerUtilities.createSession, wait: milliseconds => defaultRunnerUtilities.wait(Math.min(milliseconds, Math.max(0, deadline - Date.now()))), subscribeSignals: handler => { interrupt = handler; const unsubscribe = defaultRunnerUtilities.subscribeSignals(handler); return () => { interrupt = () => { }; unsubscribe(); }; } });
+    const result = await enforcePreviewDeadline(runner, () => interrupt(), () => player.stop(), Math.max(0, deadline - Date.now()));
+    validatePreviewResult(result);
+}
+export function validatePreviewResult(result) { if (result.status !== 'played' && result.status !== 'dismissed')
+    throw new Error(result.message ?? `Alarm preview did not play (${result.status ?? 'unknown'}).`); }
+export function rejectAt(deadline, message) { return new Promise((_, reject) => { const timer = setTimeout(() => reject(new Error(message)), Math.max(0, deadline - Date.now())); timer.unref(); }); }
+export async function enforcePreviewDeadline(runner, interrupt, stop, timeoutMs = 10_000, cleanupMs = 1_500) { let timer; const timeout = new Promise(resolve => { timer = setTimeout(() => resolve({ timeout: true }), timeoutMs); }); let result; try {
+    result = await Promise.race([runner.then(value => ({ value })), timeout]);
+}
+finally {
+    if (timer)
+        clearTimeout(timer);
+} if ('value' in result)
+    return result.value; interrupt(); const cleanupDeadline = Date.now() + cleanupMs; await settleWithin(Promise.resolve().then(stop).catch(() => undefined), cleanupDeadline); await settleWithin(runner.then(() => undefined, () => undefined), cleanupDeadline); throw new Error(`Alarm preview exceeded its ${Math.round(timeoutMs / 1000)}-second playback safety limit; cleanup was given ${cleanupMs}ms.`); }
+async function settleWithin(promise, deadline) { const remaining = Math.max(0, deadline - Date.now()); if (remaining === 0)
+    return; let timer; try {
+    await Promise.race([promise, new Promise(resolve => { timer = setTimeout(resolve, remaining); })]);
+}
+finally {
+    if (timer)
+        clearTimeout(timer);
+} }
+function createInput(options, station) { return { label: String(options.values.get('label') || station.name), enabled: !options.values.has('disabled'), station, schedule: scheduleFrom(options), playback: { volume: integer(String(options.values.get('volume') ?? '40'), 'volume', 0, 100), fadeSeconds: durationSeconds(String(options.values.get('fade') ?? '0')), stopAfterMinutes: durationMinutes(String(options.values.get('stop-after') ?? '60')), fallbackStation: options.values.has('fallback') ? undefined : undefined }, reliability: { missedRunGraceMinutes: integer(String(options.values.get('grace') ?? '10'), 'grace', 0, 10080), wakeIfSupported: options.values.has('wake'), keepAwakeUntilAlarm: options.values.has('guard') } }; }
+function updatesFromOptions(options, store, alarm) { const station = options.values.has('station') ? resolveStation(store, String(options.values.get('station'))) : alarm.station; const playback = { ...alarm.playback }; if (options.values.has('volume'))
+    playback.volume = integer(String(options.values.get('volume')), 'volume', 0, 100); if (options.values.has('fade'))
+    playback.fadeSeconds = durationSeconds(String(options.values.get('fade'))); if (options.values.has('stop-after'))
+    playback.stopAfterMinutes = durationMinutes(String(options.values.get('stop-after'))); if (options.values.has('fallback'))
+    playback.fallbackStation = resolveStation(store, String(options.values.get('fallback'))); if (options.values.has('clear-fallback'))
+    delete playback.fallbackStation; const reliability = { ...alarm.reliability }; if (options.values.has('grace'))
+    reliability.missedRunGraceMinutes = integer(String(options.values.get('grace')), 'grace', 0, 10080); if (options.values.has('wake'))
+    reliability.wakeIfSupported = true; if (options.values.has('no-wake'))
+    reliability.wakeIfSupported = false; if (options.values.has('guard'))
+    reliability.keepAwakeUntilAlarm = true; if (options.values.has('no-guard'))
+    reliability.keepAwakeUntilAlarm = false; const changesSchedule = options.values.has('once') || options.values.has('time') || options.values.has('days') || options.values.has('timezone'); return { ...(options.values.has('label') ? { label: String(options.values.get('label')) } : {}), ...(options.values.has('station') ? { station } : {}), ...(changesSchedule ? { schedule: scheduleEdit(options, alarm.schedule) } : {}), playback, reliability }; }
+function scheduleFrom(options) { if (options.values.has('once')) {
+    const input = String(options.values.get('once'));
+    const instant = new Date(input);
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(input) || !Number.isFinite(instant.getTime()) || instant.getUTCSeconds() !== 0 || instant.getUTCMilliseconds() !== 0)
+        throw new Error('--once requires an absolute ISO-8601 minute with an offset or Z and zero seconds.');
+    return { type: 'once', at: instant.toISOString() };
+} const time = canonicalizeAlarmTime(required(options, 'time')); const days = parseDays(String(options.values.get('days') ?? 'daily')); const timezone = canonicalizeTimeZone(String(options.values.get('timezone') ?? Intl.DateTimeFormat().resolvedOptions().timeZone)); return { type: 'recurring', time, weekdays: days, timezone }; }
+function scheduleEdit(options, current) { if (options.values.has('once'))
+    return scheduleFrom(options); if (current.type !== 'recurring' && !options.values.has('time'))
+    throw new Error('Changing days or timezone on a one-time alarm also requires --time.'); return { type: 'recurring', time: canonicalizeAlarmTime(String(options.values.get('time') ?? (current.type === 'recurring' ? current.time : ''))), weekdays: options.values.has('days') ? parseDays(String(options.values.get('days'))) : (current.type === 'recurring' ? current.weekdays : [1, 2, 3, 4, 5, 6, 7]), timezone: canonicalizeTimeZone(String(options.values.get('timezone') ?? (current.type === 'recurring' ? current.timezone : Intl.DateTimeFormat().resolvedOptions().timeZone))) }; }
+function parseDays(value) { if (value === 'daily')
+    return [1, 2, 3, 4, 5, 6, 7]; if (value === 'weekdays')
+    return [1, 2, 3, 4, 5]; if (value === 'weekends')
+    return [6, 7]; return canonicalizeIsoWeekdays(value.split(',').map(Number)); }
+function resolveStation(store, key) { const state = store.snapshot(); const stations = [...state.favorites, ...state.imported, ...state.recent.map(item => item.station), ...state.alarms.flatMap(alarm => [alarm.station, ...(alarm.playback.fallbackStation ? [alarm.playback.fallbackStation] : [])])]; const station = stations.find(item => stationKey(item) === key); if (!station)
+    throw new Error(`Station not found: ${key}. Add it to favorites/imports/recents first.`); return station; }
+function parseOptions(args) { const allowed = new Set(['station', 'once', 'time', 'days', 'timezone', 'label', 'volume', 'fade', 'stop-after', 'fallback', 'grace', 'disabled', 'wake', 'no-wake', 'guard', 'no-guard', 'clear-fallback']); const values = new Map(); const positionals = []; for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith('--')) {
+        positionals.push(arg);
+        continue;
+    }
+    const key = arg.slice(2);
+    if (!allowed.has(key))
+        throw new Error(`Unknown alarm option: --${key}`);
+    if (values.has(key))
+        throw new Error(`Duplicate alarm option: --${key}`);
+    if (['disabled', 'wake', 'no-wake', 'guard', 'no-guard', 'clear-fallback'].includes(key)) {
+        values.set(key, true);
+        continue;
+    }
+    const value = args[++index];
+    if (!value || value.startsWith('--'))
+        throw new Error(`Missing value for --${key}.`);
+    values.set(key, value);
+} if (values.has('once') && values.has('time'))
+    throw new Error('Choose either --once or --time, not both.'); if (values.has('wake') && values.has('no-wake'))
+    throw new Error('Choose either --wake or --no-wake.'); if (values.has('guard') && values.has('no-guard'))
+    throw new Error('Choose either --guard or --no-guard.'); if (values.has('fallback') && values.has('clear-fallback'))
+    throw new Error('Choose either --fallback or --clear-fallback.'); return { values, positionals }; }
+function required(options, key) { const value = options.values.get(key); if (typeof value !== 'string' || !value)
+    return (() => { throw new Error(`Missing --${key}.`); })(); return value; }
+function requiredPos(values, index) { const value = values[index]; if (!value)
+    throw new Error(alarmUsage()); return value; }
+function integer(value, label, min, max) { const number = Number(value); if (!Number.isInteger(number) || number < min || number > max)
+    throw new Error(`${label} must be an integer from ${min} to ${max}.`); return number; }
+function durationSeconds(value) { const match = /^(\d+)(s|m)?$/.exec(value); if (!match)
+    throw new Error('Fade must be seconds (30s) or minutes (1m).'); return integer(match[1], 'fade', 0, 3600) * (match[2] === 'm' ? 60 : 1); }
+function durationMinutes(value) { const match = /^(\d+)(m|h)?$/.exec(value); if (!match)
+    throw new Error('Stop-after must be minutes (60m) or hours (2h).'); const minutes = Number(match[1]) * (match[2] === 'h' ? 60 : 1); return integer(String(minutes), 'stop-after', 1, 10080); }
+function requireAlarm(store, id) { if (!id)
+    throw new Error(alarmUsage()); const alarm = store.getAlarm(id); if (!alarm)
+    throw new Error(`Alarm not found: ${id}`); return alarm; }
+async function requireActive(args = []) { const selectors = parseActiveSelectors(args); const clients = await connectActiveAlarms(); const matches = []; for (const client of clients) {
+    const status = await client.status();
+    if ((!selectors.alarmId || status.alarmId === selectors.alarmId) && (!selectors.occurrenceAt || status.scheduledAt === selectors.occurrenceAt))
+        matches.push(client);
+} if (!matches.length)
+    throw new Error('No matching alarm is currently playing.'); if (matches.length > 1)
+    throw new Error('Multiple alarms are playing; select one with --alarm <id> and optionally --occurrence <ISO>.'); return matches[0]; }
+async function syncSaved(scheduler, alarm) { try {
+    await scheduler.sync(alarm);
+}
+catch (error) {
+    throw new Error(`Alarm ${alarm.id} was saved, but scheduler setup is degraded: ${error instanceof Error ? error.message : String(error)}`);
+} }
+async function reconcileAlarmGuard(alarm, guards = new AlarmGuardService(new AlarmPowerGuardStore())) { if (alarm.enabled && alarm.reliability.keepAwakeUntilAlarm)
+    return guards.start(alarm); await guards.stop(alarm.id); return null; }
+function formatAlarm(alarm) { const next = nextOccurrenceForAlarm(alarm, new Date())?.toISOString() ?? 'none'; return `${alarm.enabled ? 'on ' : 'off'}\t${alarm.id}\t${alarm.label}\t${alarm.station.name}\t${next}`; }
+export function alarmUsage() { return 'Usage: radiocli alarm list|show <id>|add --station provider:id (--once ISO | --time HH:mm [--days daily|weekdays|weekends|1,2])|edit <id>|enable <id>|disable <id>|remove <id>|test <id>|sync|doctor|status [--alarm <id> --occurrence <ISO>]|dismiss [--alarm <id> --occurrence <ISO>]|snooze <minutes> [--alarm <id> --occurrence <ISO>]|keep-playing [--alarm <id> --occurrence <ISO>]|guard start <id>|stop|status'; }
+async function statusesOf(clients) { return Promise.all(clients.map(client => client.status())); }
+export function runnerPowerActive(active, entries) { const playing = new Set(active.map(item => `${item.alarmId}\0${new Date(item.scheduledAt).toISOString()}`)); return entries.some(item => item.occurrenceAt && playing.has(`${item.alarmId}\0${new Date(item.occurrenceAt).toISOString()}`) && item.component === 'power' && item.active === true && item.healthy); }
+async function selectedActiveStatuses(args) { const selectors = parseActiveSelectors(args); return (await statusesOf(await connectActiveAlarms())).filter(status => (!selectors.alarmId || status.alarmId === selectors.alarmId) && (!selectors.occurrenceAt || status.scheduledAt === selectors.occurrenceAt)); }
+export function parseActiveSelectors(args) { let alarmId; let occurrenceAt; for (let index = 0; index < args.length; index += 1) {
+    const key = args[index];
+    const value = args[++index];
+    if ((key !== '--alarm' && key !== '--occurrence') || !value)
+        throw new Error('Use --alarm <id> and optionally --occurrence <absolute ISO instant>.');
+    if (key === '--alarm')
+        alarmId = value;
+    else {
+        if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(value) || !Number.isFinite(Date.parse(value)))
+            throw new Error('--occurrence must be an absolute ISO instant.');
+        occurrenceAt = new Date(value).toISOString();
+    }
+} return { alarmId, occurrenceAt }; }