watch-tail 0.1.0

package/dist/cli/server.js

@@ -0,0 +1,126 @@
+/**
+ * Process management for the CLI: locate the built SvelteKit server, start it
+ * with the resolved environment, wait until it answers, and open the browser.
+ *
+ * Every value that can be computed without side effects is a separate pure
+ * helper so it can be unit tested.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** Where the adapter-node server lives inside the package. */
+const SERVER_ENTRY = join('build', 'index.js');
+/**
+ * Walks up from the compiled CLI file until it finds `build/index.js`.
+ *
+ * Works both from `dist/cli/` in an installed package and from `src/cli/` in
+ * the repository, and returns `null` when the app has not been built yet.
+ */
+export function findAppRoot(startDir, levels = 4) {
+    let current = resolve(startDir);
+    for (let depth = 0; depth <= levels; depth += 1) {
+        if (existsSync(join(current, SERVER_ENTRY)) && existsSync(join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+/** App root as seen from this module. */
+export function appRootFromHere(metaUrl = import.meta.url) {
+    return findAppRoot(dirname(fileURLToPath(metaUrl)));
+}
+/** The URL the UI is served on, as a user would type it. */
+export function uiUrl(host, port) {
+    const display = host === '0.0.0.0' || host === '::' ? 'localhost' : host;
+    return `http://${display}:${port}`;
+}
+/** Health endpoint used to detect readiness. */
+export function healthUrl(baseUrl) {
+    return new URL('/api/health', baseUrl).toString();
+}
+/** Command that opens `url` in the platform browser. */
+export function browserCommand(url, platform = process.platform) {
+    if (platform === 'darwin')
+        return { command: 'open', args: [url] };
+    if (platform === 'win32')
+        return { command: 'cmd', args: ['/c', 'start', '', url] };
+    return { command: 'xdg-open', args: [url] };
+}
+/** Starts the production server and returns its handle. */
+export function startServer(input) {
+    const env = {
+        ...input.env,
+        PORT: String(input.port),
+        HOST: input.host,
+        ORIGIN: uiUrl(input.host, input.port),
+    };
+    return spawn(process.execPath, [join(input.appRoot, SERVER_ENTRY)], {
+        cwd: input.appRoot,
+        env,
+        // Without --verbose the server's stdout is noise: the CLI already reports
+        // readiness. stderr stays connected so real failures are never swallowed.
+        stdio: input.verbose === true ? 'inherit' : ['ignore', 'ignore', 'inherit'],
+        shell: false,
+    });
+}
+/**
+ * Polls `/api/health` until the server answers or the timeout expires.
+ *
+ * The endpoint reports the app's own state, so readiness does not depend on AWS
+ * credentials being valid.
+ */
+export async function waitForHealth(url, options = {}) {
+    const { timeoutMs = 20_000, intervalMs = 150, fetchImpl = fetch, signal } = options;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (signal?.aborted === true)
+            return false;
+        try {
+            const response = await fetchImpl(url, { signal: signal ?? AbortSignal.timeout(2000) });
+            if (response.ok)
+                return true;
+        }
+        catch {
+            // Not up yet (or still compiling): keep polling.
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, intervalMs));
+    }
+    return false;
+}
+/** Opens `url` in the browser, ignoring failures (headless machines). */
+export function openBrowser(url, options = {}) {
+    const { platform = process.platform, spawnImpl = spawn } = options;
+    const { command, args } = browserCommand(url, platform);
+    try {
+        const child = spawnImpl(command, args, { stdio: 'ignore', detached: true, shell: false });
+        child.on('error', () => undefined);
+        child.unref();
+    }
+    catch {
+        // Opening a browser is a convenience, never a failure.
+    }
+}
+/**
+ * Stops the server: SIGTERM first, SIGKILL after `graceMs`.
+ *
+ * Resolves with the exit code the CLI should report.
+ */
+export function stopServer(child, graceMs = 3000) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return Promise.resolve(child.exitCode ?? 0);
+    }
+    return new Promise((resolveExit) => {
+        const timer = setTimeout(() => child.kill('SIGKILL'), graceMs);
+        timer.unref?.();
+        child.once('close', (code, signal) => {
+            clearTimeout(timer);
+            resolveExit(code ?? (signal === null ? 0 : 130));
+        });
+        child.kill('SIGTERM');
+    });
+}

package/dist/cli/ui.js

@@ -0,0 +1,75 @@
+/**
+ * Terminal presentation for the CLI.
+ *
+ * Interactive terminals get the Bombshell (`@clack/prompts`) experience -
+ * banner, spinner, autocomplete prompts. Anything else (pipes, CI, `--no-color`)
+ * falls back to plain lines, which also keeps the integration tests readable.
+ */
+import { autocomplete, cancel, intro, isCancel, log, outro, spinner } from '@clack/prompts';
+/** Decides whether the process can render animated output and ask questions. */
+export function isInteractive(env = process.env) {
+    if (env.CI !== undefined && env.CI !== '' && env.CI !== 'false')
+        return false;
+    if (env.WATCH_TAIL_PLAIN === '1')
+        return false;
+    if (env.NO_COLOR !== undefined && env.NO_COLOR !== '')
+        return false;
+    return process.stdout.isTTY === true && process.stdin.isTTY === true;
+}
+/**
+ * Builds the presentation layer.
+ *
+ * The non-interactive branch never touches `@clack/prompts`, so piping the CLI
+ * into a file or a test harness produces stable, greppable output.
+ */
+export function createUi(options = {}) {
+    const interactive = options.interactive ?? isInteractive();
+    const spin = interactive ? spinner() : null;
+    if (!interactive) {
+        return {
+            interactive,
+            intro: (text) => console.log(text),
+            outro: (text) => console.log(text),
+            info: (text) => console.log(text),
+            warn: (text) => console.warn(`warning: ${text}`),
+            startSpinner: (text) => console.log(text),
+            stopSpinner: (text) => console.log(text),
+            failSpinner: (text) => console.error(text),
+            choose: async (_message, choices, initial) => {
+                const fallback = initial ?? choices[0]?.value ?? null;
+                return fallback;
+            },
+        };
+    }
+    return {
+        interactive,
+        intro: (text) => intro(text),
+        outro: (text) => outro(text),
+        info: (text) => log.info(text),
+        warn: (text) => log.warn(text),
+        startSpinner: (text) => spin?.start(text),
+        stopSpinner: (text) => spin?.stop(text),
+        failSpinner: (text) => {
+            spin?.stop();
+            log.error(text);
+        },
+        choose: async (message, choices, initial) => {
+            if (choices.length === 0)
+                return null;
+            const answer = await autocomplete({
+                message,
+                options: choices.map((choice) => ({
+                    value: choice.value,
+                    label: choice.label ?? choice.value,
+                })),
+                initialValue: initial ?? undefined,
+                maxItems: 12,
+            });
+            if (isCancel(answer)) {
+                cancel('Cancelled.');
+                return null;
+            }
+            return String(answer);
+        },
+    };
+}

package/dist/lib/cli/aws.js

@@ -0,0 +1,264 @@
+/**
+ * AWS profile, region and child-environment helpers shared by the `watch-tail`
+ * CLI and the development launcher (`scripts/dev.ts`).
+ *
+ * Everything here is pure apart from reading `~/.aws/config` and
+ * `~/.aws/credentials`, so it can be unit tested without spawning anything and
+ * reused by both entry points.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Name of the git-ignored file with the local emulator settings. */
+export const LOCAL_ENV_FILE = '.env.local';
+/**
+ * Variables that point a run at a local emulator or at static keys.
+ *
+ * A blank value behaves as "unset" everywhere: the SDK's endpoint override
+ * ignores an empty string, and its environment credential provider skips blank
+ * keys, so blanking is enough to hand the run back to the ambient profile.
+ */
+export const LOCAL_OVERRIDE_KEYS = [
+    'AWS_ENDPOINT_URL',
+    'AWS_ENDPOINT_URL_LOGS',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_SESSION_TOKEN',
+];
+/**
+ * `.env.local` also pins `AWS_REGION=us-east-1`, and `readEnv()` merges
+ * `process.env` last, so a `--profile` run would never reach the profile's own
+ * region (see ARCHITECTURE.md region precedence).
+ *
+ * Unlike the endpoint and credential variables, a *blank* region is not "unset"
+ * for the SDK: an empty `AWS_REGION` makes the region provider throw
+ * (`Region not accepted: region="" is not a valid hostname component`). These
+ * keys are therefore blanked only as a last resort; {@link resolveRunRegion}
+ * fills in a real value whenever one can be found, and when none can be the app
+ * reports its clear "no region configured" error instead of silently using
+ * floci's region.
+ */
+export const REGION_KEYS = ['AWS_REGION', 'AWS_DEFAULT_REGION'];
+/** Parses a TCP port, or returns `null` when the value is not a usable port. */
+export function parsePort(value) {
+    const trimmed = value.trim();
+    if (!/^\d{1,5}$/.test(trimmed))
+        return null;
+    const port = Number(trimmed);
+    return port >= 1 && port <= 65535 ? port : null;
+}
+/** Inner text of every `[section]` header line, comments and blank lines skipped. */
+function sectionHeaders(text) {
+    const headers = [];
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (line.length === 0 || line.startsWith('#') || line.startsWith(';'))
+            continue;
+        const match = /^\[([^\]]+)\]$/.exec(line);
+        if (match)
+            headers.push(match[1].trim());
+    }
+    return headers;
+}
+/** Deterministic ordering that does not depend on the platform locale. */
+function compareNames(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+/**
+ * Profile names defined by a shared config file and a credentials file.
+ *
+ * Section parsing is deliberately simple: `[profile NAME]` and `[default]` in
+ * `~/.aws/config` (so `[sso-session x]` is ignored), `[NAME]` in
+ * `~/.aws/credentials`. The result is de-duplicated, `default` first, then
+ * sorted.
+ */
+export function collectProfiles(configText, credentialsText) {
+    const found = new Set();
+    for (const header of sectionHeaders(configText)) {
+        const named = /^profile\s+(.+)$/.exec(header);
+        if (named !== null)
+            found.add(named[1].trim());
+        else if (header === 'default')
+            found.add('default');
+    }
+    for (const header of sectionHeaders(credentialsText)) {
+        if (header.length > 0)
+            found.add(header);
+    }
+    const rest = [...found]
+        .filter((name) => name !== 'default' && name.length > 0)
+        .toSorted(compareNames);
+    return found.has('default') ? ['default', ...rest] : rest;
+}
+/** Reads a text file, returning an empty string when it is missing or unreadable. */
+function readTextFile(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+/** Shared config and credentials file paths, honoring the standard overrides. */
+export function profileFiles(env = process.env) {
+    const config = env.AWS_CONFIG_FILE?.trim();
+    const credentials = env.AWS_SHARED_CREDENTIALS_FILE?.trim();
+    return {
+        configFile: config !== undefined && config.length > 0 ? config : join(homedir(), '.aws', 'config'),
+        credentialsFile: credentials !== undefined && credentials.length > 0
+            ? credentials
+            : join(homedir(), '.aws', 'credentials'),
+    };
+}
+/** Profile names found in the AWS shared config and credentials files. */
+export function readProfiles(env = process.env) {
+    const { configFile, credentialsFile } = profileFiles(env);
+    return collectProfiles(readTextFile(configFile), readTextFile(credentialsFile));
+}
+/**
+ * `region = ...` of one profile section in `~/.aws/config`, or `null` when that
+ * section is missing or has no region.
+ */
+export function readProfileRegion(configText, profile) {
+    const wanted = new Set(profile === 'default' ? ['default', 'profile default'] : [`profile ${profile}`]);
+    let section = null;
+    for (const raw of configText.split('\n')) {
+        const line = raw.trim();
+        if (line.length === 0 || line.startsWith('#') || line.startsWith(';'))
+            continue;
+        const header = /^\[([^\]]+)\]$/.exec(line);
+        if (header !== null) {
+            section = header[1].trim();
+            continue;
+        }
+        if (section === null || !wanted.has(section))
+            continue;
+        const pair = /^region\s*=\s*(.*)$/.exec(line);
+        if (pair === null)
+            continue;
+        const value = pair[1].replace(/\s[#;].*$/, '').trim();
+        if (value.length > 0)
+            return value;
+    }
+    return null;
+}
+/** Trims a value and treats blank strings as absent. */
+function normalize(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+/**
+ * Region to hand to the child, mirroring the app's documented precedence:
+ * `--region`, then `AWS_REGION`/`AWS_DEFAULT_REGION` exported in the shell, then
+ * the region of the requested profile in `~/.aws/config`.
+ *
+ * Returns `null` when nothing can be resolved. The caller then blanks the region
+ * keys, and the app answers with "No AWS region is configured..." instead of
+ * silently keeping the region that `.env.local` pins for floci.
+ */
+export function resolveRunRegion({ region = null, profile = null, base, configText, }) {
+    const explicit = normalize(region);
+    if (explicit !== null)
+        return explicit;
+    const exported = normalize(base.AWS_REGION) ?? normalize(base.AWS_DEFAULT_REGION);
+    if (exported !== null)
+        return exported;
+    const name = normalize(profile);
+    if (name === null)
+        return null;
+    return readProfileRegion(configText, name);
+}
+/** Throwaway credentials local emulators accept; floci never checks them. */
+const EMULATOR_CREDENTIALS = { accessKeyId: 'test', secretAccessKey: 'test' };
+/**
+ * Builds the environment for the child process.
+ *
+ * Without `profile` the base environment is returned unchanged, so plain
+ * `pnpm dev` behaves exactly as before. With `profile` the local emulator
+ * settings (endpoint, static keys and the pinned region) are blanked and
+ * `AWS_PROFILE` is set, so the SDK resolves credentials and region from that
+ * profile; a non-blank `region` is then applied as `AWS_REGION` and
+ * `AWS_DEFAULT_REGION`, which is how `--region` (or a region resolved by
+ * {@link resolveRunRegion}) wins over the profile.
+ */
+export function buildChildEnv({ base, profile = null, region = null, endpoint = null, }) {
+    const env = { ...base };
+    const name = normalize(profile);
+    const emulator = normalize(endpoint);
+    if (name !== null) {
+        env.AWS_PROFILE = name;
+        for (const key of [...LOCAL_OVERRIDE_KEYS, ...REGION_KEYS])
+            env[key] = '';
+    }
+    if (emulator !== null) {
+        env.AWS_ENDPOINT_URL = emulator;
+        env.AWS_ENDPOINT_URL_LOGS = emulator;
+        // Local emulators accept any non-empty key pair. Never override keys the
+        // caller already configured: they may be signing for something real.
+        if (normalize(base.AWS_ACCESS_KEY_ID) === null) {
+            env.AWS_ACCESS_KEY_ID = EMULATOR_CREDENTIALS.accessKeyId;
+            env.AWS_SECRET_ACCESS_KEY = EMULATOR_CREDENTIALS.secretAccessKey;
+        }
+    }
+    const code = normalize(region);
+    if (code !== null) {
+        env.AWS_REGION = code;
+        env.AWS_DEFAULT_REGION = code;
+    }
+    return env;
+}
+/** True when the endpoint points at a local emulator rather than real AWS. */
+export function isEmulatorEndpoint(endpoint) {
+    let hostname = '';
+    try {
+        hostname = new URL(endpoint).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return (hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '::1' ||
+        hostname.endsWith('.localhost') ||
+        hostname.includes('floci') ||
+        hostname.includes('localstack'));
+}
+/**
+ * `AWS_*` entries of a child environment as `KEY=value` lines, sorted by name.
+ *
+ * Blank values are kept: seeing `AWS_ENDPOINT_URL=` is how you confirm that the
+ * local emulator settings were neutralized for this run.
+ */
+export function describeChildEnv(env) {
+    return Object.keys(env)
+        .filter((key) => key.startsWith('AWS_'))
+        .toSorted(compareNames)
+        .map((key) => `${key}=${env[key] ?? ''}`);
+}
+/** Reads the shared AWS config file, or an empty string when it is missing. */
+export function readConfigText(env = process.env) {
+    return readTextFile(profileFiles(env).configFile);
+}
+/** True when `.env.local` (the floci settings) exists in the repository root. */
+export function isLocalEnvPresent(cwd = process.cwd()) {
+    return existsSync(join(cwd, LOCAL_ENV_FILE));
+}
+/** Exit code for a child killed by a signal, following the shell convention. */
+export function signalExitCode(signal) {
+    switch (signal) {
+        case 'SIGINT':
+            return 130;
+        case 'SIGQUIT':
+            return 131;
+        case 'SIGTERM':
+            return 143;
+        case 'SIGHUP':
+            return 129;
+        default:
+            return 1;
+    }
+}

package/dist/lib/time-range.js

@@ -0,0 +1,106 @@
+/**
+ * Historic time-range helpers shared by the server and the browser.
+ *
+ * The preset list lives here so the API and the picker can never drift apart.
+ * Everything is pure; nothing here touches the DOM.
+ */
+/** Preset windows offered by the historic range picker. */
+export const HISTORIC_PRESETS = ['15m', '1h', '3h', '12h', '24h', '5d'];
+/** Human labels for the preset chips. */
+export const PRESET_LABELS = {
+    '15m': '15 min',
+    '1h': '1 hour',
+    '3h': '3 hours',
+    '12h': '12 hours',
+    '24h': '24 hours',
+    '5d': '5 days',
+};
+const UNIT_MS = {
+    ms: 1,
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+};
+const DURATION_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/i;
+/** True when the value is one of the offered presets. */
+export function isHistoricPreset(value) {
+    return HISTORIC_PRESETS.includes(value);
+}
+/** Duration of a preset window in milliseconds. */
+export function presetDurationMs(preset) {
+    const match = DURATION_PATTERN.exec(preset);
+    const amount = match === null ? 0 : Number(match[1]);
+    const unit = match === null ? 0 : (UNIT_MS[match[2].toLowerCase()] ?? 0);
+    return amount * unit;
+}
+/** Label for a preset, falling back to the raw value. */
+export function presetLabel(preset) {
+    return isHistoricPreset(preset) ? PRESET_LABELS[preset] : preset;
+}
+/**
+ * Converts epoch milliseconds to the `YYYY-MM-DDTHH:mm` string a
+ * `datetime-local` input expects, in the browser's local time zone.
+ */
+/** Zero-pads a number for the `datetime-local` format. */
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+export function toDateTimeLocal(epochMs) {
+    const date = new Date(epochMs);
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+/**
+ * Converts a `datetime-local` value back to epoch milliseconds.
+ *
+ * The string is timezone-less, so it is interpreted in local time; `NaN` input
+ * returns `null`.
+ */
+export function fromDateTimeLocal(value) {
+    if (typeof value !== 'string' || value.trim() === '')
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+/** Formats a window bound for display, for example `14:05` or `10 May 14:05`. */
+export function formatWindowBound(epochMs, now) {
+    const date = new Date(epochMs);
+    const time = `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+    const sameDay = new Date(now).toDateString() === date.toDateString();
+    if (sameDay)
+        return time;
+    const day = date.toLocaleDateString(undefined, { day: 'numeric', month: 'short' });
+    return `${day} ${time}`;
+}
+/**
+ * Describes the window reported by the server's `ready` event.
+ *
+ * Live tails report the lookback window; historic tails report the resolved
+ * range, naming the preset when one was used.
+ */
+export function describeWindow(ready, now) {
+    if (ready === null || ready.startTime === undefined) {
+        return { mode: 'live', label: 'live', title: 'Tailing new events', clamped: false };
+    }
+    const clamped = ready.clamped === true;
+    if (ready.mode !== 'historic' || ready.endTime === null || ready.endTime === undefined) {
+        return {
+            mode: 'live',
+            label: 'live',
+            title: `Live since ${formatWindowBound(ready.startTime, now)}`,
+            clamped,
+        };
+    }
+    const from = formatWindowBound(ready.startTime, now);
+    const to = formatWindowBound(ready.endTime, now);
+    const preset = ready.preset === null || ready.preset === undefined ? null : presetLabel(ready.preset);
+    return {
+        mode: 'historic',
+        label: preset === null ? `${from} → ${to}` : `${preset} · ${from} → ${to}`,
+        title: clamped
+            ? 'Historic window, clamped to the last 14 days that CloudWatch Logs keeps'
+            : 'Historic window',
+        clamped,
+    };
+}

package/package.json

@@ -0,0 +1,106 @@
+{
+	"name": "watch-tail",
+	"version": "0.1.0",
+	"description": "Tail Amazon CloudWatch Logs in your browser: a local SvelteKit UI with live and historic streaming, ambient AWS credentials and floci support",
+	"keywords": [
+		"aws",
+		"cli",
+		"cloudwatch",
+		"cloudwatch-logs",
+		"floci",
+		"localstack",
+		"log-viewer",
+		"logs",
+		"sveltekit",
+		"tail",
+		"tailwindcss"
+	],
+	"homepage": "https://github.com/antstanley/watch-stream#readme",
+	"bugs": "https://github.com/antstanley/watch-stream/issues",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/antstanley/watch-stream.git"
+	},
+	"bin": {
+		"watch-tail": "./dist/cli/bin.js"
+	},
+	"files": [
+		"dist",
+		"build",
+		"README.md",
+		"LICENSE"
+	],
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && tsc -p tsconfig.cli.json",
+		"preview": "vite preview",
+		"start": "node dist/cli/bin.js",
+		"prepare": "svelte-kit sync || echo ''",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:unit": "vitest run",
+		"lint": "oxlint",
+		"lint:fix": "oxlint --fix",
+		"format": "oxfmt --write .",
+		"format:check": "oxfmt --check .",
+		"knip": "knip",
+		"verify": "pnpm check && pnpm lint && pnpm format:check && pnpm test && pnpm knip && pnpm build",
+		"floci:start": "floci start",
+		"floci:stop": "floci stop",
+		"floci:env": "node scripts/floci-env.ts",
+		"floci:up": "floci start && node scripts/floci-env.ts",
+		"seed": "node scripts/seed-floci.ts",
+		"seed:watch": "node scripts/seed-floci.ts --watch",
+		"test:e2e": "WATCH_STREAM_E2E=1 vitest run --project integration",
+		"dev:aws": "node scripts/dev.ts",
+		"start:aws": "node scripts/dev.ts --start",
+		"test:ui": "node scripts/ui-smoke.ts",
+		"build:app": "vite build",
+		"build:cli": "tsc -p tsconfig.cli.json",
+		"prepack": "pnpm build",
+		"watch-tail": "node dist/cli/bin.js",
+		"publish:check": "publint && npm pack --dry-run",
+		"test:cli": "WATCH_TAIL_E2E=1 vitest run --project integration tests/cli-server.spec.ts",
+		"changeset": "changeset",
+		"changeset:version": "changeset version && pnpm install --no-frozen-lockfile"
+	},
+	"dependencies": {
+		"@aws-sdk/client-cloudwatch-logs": "^3.1129.0",
+		"@bomb.sh/args": "^0.3.1",
+		"@bomb.sh/tab": "^0.0.22",
+		"@clack/prompts": "^1.8.0"
+	},
+	"devDependencies": {
+		"@changesets/changelog-github": "^1.0.1",
+		"@changesets/cli": "^3.0.2",
+		"@sveltejs/adapter-node": "^5.5.4",
+		"@sveltejs/kit": "^2.63.0",
+		"@sveltejs/vite-plugin-svelte": "^7.1.2",
+		"@tailwindcss/vite": "^4.3.0",
+		"@testing-library/svelte": "^5.4.2",
+		"@types/node": "^22.20.2",
+		"jsdom": "^30.0.1",
+		"knip": "^6.35.1",
+		"oxfmt": "^0.67.0",
+		"oxlint": "^1.82.0",
+		"playwright": "^1.63.0",
+		"publint": "^0.3.24",
+		"svelte": "^5.56.1",
+		"svelte-check": "^4.6.0",
+		"tailwindcss": "^4.3.0",
+		"typescript": "^6.0.3",
+		"vite": "^8.0.16",
+		"vitest": "^4.1.8"
+	},
+	"engines": {
+		"node": ">=22"
+	},
+	"packageManager": "pnpm@11.24.0"
+}