@swimmingliu/autovpn 1.4.0

package/dist/cli/native-commands.js

@@ -0,0 +1,215 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { artifactLatest, artifactList } from '../artifacts/list.js';
+import { previewArtifact } from '../artifacts/preview.js';
+import { profilePayload, profileSummary, saveProfilePayload } from '../config/profile.js';
+import { runDoctor } from '../doctor/checks.js';
+import { publicStartedPayload, startDetachedResume, startDetachedRetry, startDetachedRun, stopManagedJob } from '../jobs/commands.js';
+import { followLog } from '../jobs/logs.js';
+import { latestJobId, listJobs, loadJob, publicJobPayload, singleActiveJobId, tailLog } from '../jobs/read.js';
+import { readOptionValue, resolveProjectRoot } from '../runtime/paths.js';
+function wantsPython(env, key) {
+    return String(env[key] ?? '').trim().toLowerCase() === 'python';
+}
+function jsonLine(payload) {
+    return `${JSON.stringify(payload)}\n`;
+}
+function positionalAfter(argv, start) {
+    for (let index = start; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value === '--project-root' || value === '--format' || value === '--tail' || value === '--output') {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--')) {
+            continue;
+        }
+        return value;
+    }
+    return '';
+}
+function hasFlag(argv, flag) {
+    return argv.includes(flag);
+}
+function outputFormat(argv) {
+    return readOptionValue(argv, '--output') === 'human' ? 'human' : 'jsonl';
+}
+function jobOptions(context) {
+    return {
+        env: context.env,
+        cwd: context.cwd,
+        spawn: context.spawn,
+        now: context.now,
+        jobId: context.jobId,
+        sleep: context.sleep
+    };
+}
+async function writeFollowLog(projectRoot, jobId, argv, context) {
+    for await (const chunk of followLog(projectRoot, jobId, argv, { env: context.env, sleep: context.sleep })) {
+        context.io.writeStdout(chunk);
+    }
+}
+function resolveResumeSessionDir(job) {
+    const candidates = [
+        String(job.resume_from ?? ''),
+        String((job.options ?? {}).session_dir ?? ''),
+        String(job.session_dir ?? '')
+    ];
+    for (const candidate of candidates) {
+        if (candidate && fs.existsSync(path.join(candidate, 'session.json'))) {
+            return candidate;
+        }
+    }
+    return '';
+}
+export async function runNativeCommand(argv, context) {
+    const projectRoot = resolveProjectRoot(argv, context.cwd);
+    const command = argv[0];
+    if (command === 'doctor') {
+        if (wantsPython(context.env, 'AUTOVPN_DOCTOR_BACKEND'))
+            return context.pythonFallback(argv);
+        if (readOptionValue(argv, '--output') !== 'json')
+            return undefined;
+        const result = runDoctor(projectRoot, argv, context.env);
+        context.io.writeStdout(jsonLine(result.payload));
+        return result.code;
+    }
+    if (command === 'profile') {
+        if (wantsPython(context.env, 'AUTOVPN_PROFILE_BACKEND'))
+            return context.pythonFallback(argv);
+        if (argv[1] === 'show') {
+            context.io.writeStdout(jsonLine(profilePayload(projectRoot, context.env)));
+            return 0;
+        }
+        if (argv[1] === 'summary') {
+            context.io.writeStdout(jsonLine(profileSummary(projectRoot, context.env)));
+            return 0;
+        }
+        if (argv[1] === 'save') {
+            const payload = JSON.parse(await context.readStdin());
+            context.io.writeStdout(jsonLine(saveProfilePayload(projectRoot, payload, context.env)));
+            return 0;
+        }
+    }
+    if (command === 'artifacts') {
+        if (wantsPython(context.env, 'AUTOVPN_ARTIFACTS_BACKEND'))
+            return context.pythonFallback(argv);
+        const subcommand = argv[1];
+        if (subcommand === 'latest') {
+            context.io.writeStdout(jsonLine(artifactLatest(projectRoot, context.env)));
+            return 0;
+        }
+        if (subcommand === 'list') {
+            context.io.writeStdout(jsonLine(artifactList(projectRoot, context.env)));
+            return 0;
+        }
+        if (subcommand === 'preview') {
+            context.io.writeStdout(jsonLine(previewArtifact(path.resolve(context.cwd, positionalAfter(argv, 2)))));
+            return 0;
+        }
+    }
+    if (command === 'run' && hasFlag(argv, '--detach')) {
+        const job = await startDetachedRun({
+            projectRoot,
+            resumeLatest: hasFlag(argv, '--resume-latest'),
+            skipDeploy: hasFlag(argv, '--skip-deploy'),
+            skipVerify: hasFlag(argv, '--skip-verify'),
+            outputFormat: outputFormat(argv)
+        }, jobOptions(context));
+        context.io.writeStdout(jsonLine(publicStartedPayload(job)));
+        return 0;
+    }
+    if (command === 'jobs') {
+        const subcommand = positionalAfter(argv, 1);
+        if (subcommand === 'list') {
+            context.io.writeStdout(jsonLine(listJobs(projectRoot, context.env)));
+            return 0;
+        }
+        if (subcommand === 'status') {
+            const jobId = positionalAfter(argv, argv.indexOf(subcommand) + 1);
+            context.io.writeStdout(jsonLine(publicJobPayload(loadJob(projectRoot, jobId, context.env))));
+            return 0;
+        }
+        if (subcommand === 'logs') {
+            const jobId = positionalAfter(argv, argv.indexOf(subcommand) + 1);
+            if (argv.includes('--follow')) {
+                await writeFollowLog(projectRoot, jobId, argv, context);
+                return 0;
+            }
+            context.io.writeStdout(tailLog(projectRoot, jobId, argv, context.env));
+            return 0;
+        }
+        if (subcommand === 'stop') {
+            const jobId = positionalAfter(argv, argv.indexOf(subcommand) + 1);
+            const job = await stopManagedJob(projectRoot, jobId, {
+                ...jobOptions(context),
+                timeoutMs: Number.parseFloat(readOptionValue(argv, '--timeout') ?? '4') * 1000
+            });
+            context.io.writeStdout(jsonLine(publicJobPayload(job)));
+            return 0;
+        }
+        if (subcommand === 'resume' && hasFlag(argv, '--detach')) {
+            const sourceJobId = positionalAfter(argv, argv.indexOf(subcommand) + 1);
+            const sourceJob = loadJob(projectRoot, sourceJobId, context.env);
+            const sessionDir = resolveResumeSessionDir(sourceJob);
+            if (!sessionDir && String(sourceJob.kind ?? '') === 'run') {
+                const sourceOptions = sourceJob.options ?? {};
+                const job = await startDetachedRun({
+                    projectRoot,
+                    sourceJobId,
+                    resumeLatest: true,
+                    skipDeploy: Boolean(sourceOptions.skip_deploy),
+                    skipVerify: Boolean(sourceOptions.skip_verify),
+                    outputFormat: outputFormat(argv)
+                }, jobOptions(context));
+                context.io.writeStdout(jsonLine(publicStartedPayload(job)));
+                return 0;
+            }
+            if (!sessionDir) {
+                throw new Error('cannot resume job without session.json');
+            }
+            const job = await startDetachedResume({
+                projectRoot,
+                sourceJobId,
+                sessionDir,
+                outputFormat: outputFormat(argv)
+            }, jobOptions(context));
+            context.io.writeStdout(jsonLine(publicStartedPayload(job)));
+            return 0;
+        }
+        if (subcommand === 'retry' && hasFlag(argv, '--detach')) {
+            const job = await startDetachedRetry({
+                projectRoot,
+                artifactDir: path.resolve(context.cwd, readOptionValue(argv, '--artifact-dir') ?? ''),
+                stage: readOptionValue(argv, '--stage') ?? '',
+                outputFormat: outputFormat(argv)
+            }, jobOptions(context));
+            context.io.writeStdout(jsonLine(publicStartedPayload(job)));
+            return 0;
+        }
+    }
+    if (command === 'status') {
+        context.io.writeStdout(jsonLine(publicJobPayload(loadJob(projectRoot, latestJobId(projectRoot, context.env), context.env))));
+        return 0;
+    }
+    if (command === 'logs') {
+        const jobId = latestJobId(projectRoot, context.env);
+        const logFormat = readOptionValue(argv, '--format');
+        const syntheticArgv = logFormat ? argv : [...argv, '--format', 'human'];
+        if (argv.includes('--follow')) {
+            await writeFollowLog(projectRoot, jobId, syntheticArgv, context);
+            return 0;
+        }
+        context.io.writeStdout(tailLog(projectRoot, jobId, syntheticArgv, context.env));
+        return 0;
+    }
+    if (command === 'stop') {
+        const job = await stopManagedJob(projectRoot, singleActiveJobId(projectRoot, context.env), {
+            ...jobOptions(context),
+            timeoutMs: Number.parseFloat(readOptionValue(argv, '--timeout') ?? '4') * 1000
+        });
+        context.io.writeStdout(jsonLine(publicJobPayload(job)));
+        return 0;
+    }
+    return undefined;
+}

package/dist/cli/output.js

@@ -0,0 +1,31 @@
+export function defaultIo() {
+    return {
+        writeStdout(chunk) {
+            process.stdout.write(chunk);
+        },
+        writeStderr(chunk) {
+            process.stderr.write(chunk);
+        }
+    };
+}
+export function renderHelp() {
+    return `AutoVPN headless command line interface
+
+Usage:
+  autovpn --help
+  autovpn --version
+  autovpn <command> [options]
+
+Commands:
+  profile show|save|summary
+  doctor
+  artifacts latest|list|preview
+  run
+  retry-stage
+  resume pipeline|speedtest
+  jobs list|status|logs|stop|resume|retry
+  status
+  logs
+  stop
+`;
+}

package/dist/config/profile.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse, stringify } from '@iarna/toml';
+import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
+const DEFAULT_SOURCE_ORDER = ['leiting', 'heidong', 'mifeng', 'xuanfeng-area', 'xuanfeng-all-area'];
+function state(value) {
+    return String(value ?? '').trim() ? 'set' : 'missing';
+}
+function readProfile(profilePath) {
+    if (!fs.existsSync(profilePath)) {
+        return {};
+    }
+    return parse(fs.readFileSync(profilePath, 'utf8'));
+}
+export function profileSummary(projectRoot, env = process.env) {
+    const profilePath = resolveProfilePath(projectRoot, env);
+    const stateRoot = path.dirname(profilePath);
+    const payload = readProfile(profilePath);
+    const rawSources = (payload.sources ?? {});
+    const sourceNames = [
+        ...DEFAULT_SOURCE_ORDER,
+        ...Object.keys(rawSources).filter((name) => !DEFAULT_SOURCE_ORDER.includes(name)).sort()
+    ];
+    const sources = Object.fromEntries(sourceNames.map((name) => {
+        const config = rawSources[name] ?? {};
+        return [
+            name,
+            {
+                enabled: Boolean(config?.enabled ?? true),
+                url: state(config?.url),
+                key: state(config?.key)
+            }
+        ];
+    }));
+    const deploy = (payload.deploy ?? {});
+    return {
+        ok: true,
+        sources,
+        deploy: {
+            project_name: String(deploy.project_name ?? ''),
+            pages_project_url: String(deploy.pages_project_url ?? ''),
+            cloudflare_api_token: state(deploy.cloudflare_api_token),
+            cloudflare_global_key: state(deploy.cloudflare_global_key),
+            cloudflare_email: state(deploy.cloudflare_email),
+            account_id: state(deploy.account_id),
+            subscription_url: state(deploy.subscription_url),
+            verify_subscription_url: state(deploy.verify_subscription_url),
+            secret_query: state(deploy.secret_query)
+        },
+        paths: {
+            project_root: projectRoot,
+            artifacts_root: resolveArtifactsRoot(projectRoot, env),
+            state_root: stateRoot,
+            profile_path: profilePath
+        }
+    };
+}
+export function profilePayload(projectRoot, env = process.env) {
+    const profilePath = resolveProfilePath(projectRoot, env);
+    const paths = {
+        project_root: projectRoot,
+        artifacts_root: resolveArtifactsRoot(projectRoot, env),
+        state_root: path.dirname(profilePath),
+        profile_path: profilePath
+    };
+    return {
+        ...readProfile(profilePath),
+        paths,
+        workspace: paths
+    };
+}
+export function saveProfilePayload(projectRoot, payload, env = process.env) {
+    const profilePath = resolveProfilePath(projectRoot, env);
+    fs.mkdirSync(path.dirname(profilePath), { recursive: true });
+    const persisted = { ...payload };
+    delete persisted.paths;
+    delete persisted.workspace;
+    fs.writeFileSync(profilePath, stringify(persisted), 'utf8');
+    return profilePayload(projectRoot, env);
+}

package/dist/doctor/checks.js

@@ -0,0 +1,184 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { parse } from '@iarna/toml';
+import { profileSummary } from '../config/profile.js';
+import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
+function check(name, status, message, details = {}) {
+    return { name, status, message, details };
+}
+function pathWritable(targetPath) {
+    const target = fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory() ? targetPath : path.dirname(targetPath);
+    try {
+        fs.mkdirSync(target, { recursive: true });
+        const probe = path.join(target, '.doctor-write-test');
+        fs.writeFileSync(probe, 'ok', 'utf8');
+        fs.rmSync(probe, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function commandPath(name, env) {
+    const pathValue = String(env.PATH ?? process.env.PATH ?? '');
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(dir, name);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return '';
+}
+function safeRun(command, env) {
+    try {
+        const result = spawnSync(command[0], command.slice(1), {
+            encoding: 'utf8',
+            env: { ...process.env, ...env },
+            timeout: 5000
+        });
+        const output = String(result.stdout || result.stderr || '').trim().split(/\r?\n/)[0] ?? '';
+        return { ok: result.status === 0, message: output || `exit ${result.status ?? 1}` };
+    }
+    catch (error) {
+        const err = error;
+        return { ok: false, message: `${err.name}: ${err.message}` };
+    }
+}
+function canBindLocalhost() {
+    const server = net.createServer();
+    try {
+        server.listen(0, '127.0.0.1');
+        server.close();
+        return true;
+    }
+    catch {
+        server.close();
+        return false;
+    }
+}
+function checkSpeedTestConfig(profile) {
+    const speed = (profile.speed_test ?? {});
+    const invalid = [];
+    if (Number(speed.timeout_seconds ?? 0) < 1)
+        invalid.push('timeout_seconds');
+    if (Number(speed.concurrency ?? 0) < 1)
+        invalid.push('concurrency');
+    if (Number(speed.min_download_mb_s ?? 0) < 0)
+        invalid.push('min_download_mb_s');
+    if (Number(speed.max_download_bytes ?? 0) < 1)
+        invalid.push('max_download_bytes');
+    if (!String(speed.probe_url ?? '').trim())
+        invalid.push('probe_url');
+    if (invalid.length) {
+        return check('speed_test_config', 'fail', 'Speed test settings are invalid', { invalid_fields: invalid });
+    }
+    return check('speed_test_config', 'pass', 'Speed test settings are valid', {
+        speed_url_count: Array.isArray(speed.urls) ? speed.urls.length : 0,
+        has_probe_url: Boolean(String(speed.probe_url ?? '').trim())
+    });
+}
+function loadProfile(profilePath) {
+    if (!fs.existsSync(profilePath)) {
+        return {};
+    }
+    return parse(fs.readFileSync(profilePath, 'utf8'));
+}
+function checkProxyRuntime(env) {
+    const checks = [];
+    const mihomo = commandPath('mihomo', env);
+    if (!mihomo) {
+        checks.push(check('mihomo', 'fail', 'mihomo binary is missing'));
+    }
+    else {
+        const result = safeRun([mihomo, '-v'], env);
+        checks.push(check('mihomo', result.ok ? 'pass' : 'fail', result.ok ? 'mihomo is executable' : 'mihomo version command failed', {
+            path: mihomo,
+            version: result.message
+        }));
+    }
+    checks.push(check('localhost_port', canBindLocalhost() ? 'pass' : 'fail', canBindLocalhost() ? 'Localhost port binding works' : 'Localhost port binding failed'));
+    const configuredKeys = [
+        'VPN_AUTOMATION_UPSTREAM_PROXY',
+        'VPN_AUTOMATION_DEPLOY_PROXY',
+        'VPN_AUTOMATION_CLOUDFLARE_PROXY',
+        'HTTP_PROXY',
+        'HTTPS_PROXY',
+        'ALL_PROXY'
+    ].filter((key) => env[key] || process.env[key]);
+    checks.push(check('proxy_environment', 'pass', 'Proxy environment inspected', { configured_keys: configuredKeys }));
+    return checks;
+}
+function checkNodeTools(projectRoot, env) {
+    const missing = ['node', 'npm', 'npx'].filter((name) => !commandPath(name, env));
+    const checks = [
+        check('node_binaries', missing.length ? 'fail' : 'pass', missing.length ? 'Node.js command line tools are missing' : 'Node.js command line tools are available', { missing })
+    ];
+    const hasPlaywright = [
+        path.join(projectRoot, 'node_modules', 'playwright'),
+        path.join(projectRoot, 'electron', 'runtime', 'node-vendor', 'node_modules', 'playwright')
+    ].some((candidate) => fs.existsSync(candidate));
+    checks.push(check('playwright', hasPlaywright ? 'pass' : 'warn', hasPlaywright ? 'Playwright package is installed' : 'Playwright package was not found; run npx playwright install --with-deps chromium-headless-shell'));
+    const npx = commandPath('npx', env);
+    if (!npx) {
+        checks.push(check('javascript_obfuscator', 'fail', 'npx is missing'));
+    }
+    else {
+        const result = safeRun([npx, 'javascript-obfuscator', '--version'], env);
+        checks.push(check('javascript_obfuscator', result.ok ? 'pass' : 'fail', result.ok ? 'javascript-obfuscator is available' : 'javascript-obfuscator is not available', { result: result.message }));
+    }
+    return checks;
+}
+function checkCloudflare(summary, deploy, env) {
+    const checks = [];
+    const deploySummary = summary.deploy ?? {};
+    const hasCredentials = deploySummary.cloudflare_api_token === 'set'
+        || Boolean((env.CLOUDFLARE_API_TOKEN ?? '').trim())
+        || (deploySummary.cloudflare_global_key === 'set' && deploySummary.cloudflare_email === 'set')
+        || (Boolean((env.CLOUDFLARE_API_KEY ?? '').trim()) && Boolean((env.CLOUDFLARE_EMAIL ?? '').trim()));
+    checks.push(check('cloudflare_credentials', hasCredentials ? 'pass' : (deploy ? 'fail' : 'warn'), hasCredentials ? 'Cloudflare credentials are configured' : 'Cloudflare credentials are missing', { auth_state: hasCredentials ? 'set' : 'missing', deploy_required: deploy }));
+    const hasAccount = deploySummary.account_id === 'set' || Boolean((env.CLOUDFLARE_ACCOUNT_ID ?? '').trim());
+    checks.push(check('cloudflare_account', hasAccount ? 'pass' : (deploy ? 'fail' : 'warn'), hasAccount ? 'Cloudflare account ID is configured' : 'Cloudflare account ID is missing', { account_state: hasAccount ? 'set' : 'missing', deploy_required: deploy }));
+    const pagesProjectUrl = String(deploySummary.pages_project_url ?? '');
+    const hasDeployUrl = Boolean(String(deploySummary.project_name ?? '').trim() && URL.canParse(pagesProjectUrl));
+    checks.push(check('deploy_urls', hasDeployUrl ? 'pass' : (deploy ? 'fail' : 'warn'), hasDeployUrl ? 'Deploy URL settings are internally consistent' : 'Deploy URL settings are incomplete', { has_project_name: Boolean(String(deploySummary.project_name ?? '').trim()), has_pages_url: URL.canParse(pagesProjectUrl) }));
+    const npx = commandPath('npx', env);
+    if (!npx) {
+        checks.push(check('wrangler', deploy ? 'fail' : 'warn', 'npx is missing'));
+    }
+    else {
+        const result = safeRun([npx, 'wrangler', 'pages', 'deploy', '--help'], env);
+        checks.push(check('wrangler', result.ok ? 'pass' : (deploy ? 'fail' : 'warn'), result.ok ? 'Wrangler Pages deploy command is available' : 'Wrangler Pages deploy command is not available', { result: result.message, deploy_required: deploy }));
+    }
+    return checks;
+}
+export function runDoctor(projectRoot, argv, env = process.env) {
+    const deploy = argv.includes('--deploy');
+    const strict = argv.includes('--strict');
+    const profilePath = resolveProfilePath(projectRoot, env);
+    const artifactsRoot = resolveArtifactsRoot(projectRoot, env);
+    const profile = loadProfile(profilePath);
+    const summary = profileSummary(projectRoot, env);
+    const sourceValues = Object.values((summary.sources ?? {}));
+    const configuredSources = sourceValues.filter((source) => source.enabled && source.url === 'set' && source.key === 'set');
+    const checks = [
+        check('node_version', 'pass', `Node ${process.versions.node}`, { required: '>=20' }),
+        check('project_root', 'pass', 'Project root resolved', { path: projectRoot }),
+        check('profile_path', pathWritable(profilePath) ? 'pass' : 'fail', pathWritable(profilePath) ? 'Profile is readable and writable' : 'Profile path is not writable', { profile_path: profilePath, exists: fs.existsSync(profilePath) }),
+        check('artifacts_root', pathWritable(artifactsRoot) ? 'pass' : 'fail', pathWritable(artifactsRoot) ? 'Artifacts root is writable' : 'Artifacts root is not writable', { path: artifactsRoot }),
+        check('worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'pass' : 'fail', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'Worker template exists' : 'Worker template is missing', { path: path.join(projectRoot, 'templates', 'vmess_node.js') }),
+        check('share_worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'pass' : 'warn', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'Share worker template exists' : 'Share worker template is missing', { path: path.join(projectRoot, 'templates', 'share-worker', 'vpn.js') }),
+        configuredSources.length
+            ? check('sources', 'pass', 'At least one enabled source is configured', { configured_count: configuredSources.length })
+            : check('sources', 'warn', 'No enabled source has both URL and key configured', { configured_count: 0, key_state: 'missing' }),
+        checkSpeedTestConfig(profile),
+        ...checkProxyRuntime(env),
+        ...checkNodeTools(projectRoot, env),
+        ...checkCloudflare(summary, deploy, env)
+    ];
+    const hasFailures = checks.some((item) => item.status === 'fail');
+    const hasWarnings = checks.some((item) => item.status === 'warn');
+    const ok = !hasFailures && !(strict && hasWarnings);
+    return { code: ok ? 0 : 1, payload: { ok, deploy, strict, project_root: projectRoot, checks } };
+}

package/dist/events/schema.js

@@ -0,0 +1,45 @@
+const KNOWN_EVENT_TYPES = new Set([
+    'run_started',
+    'log',
+    'stage',
+    'summary',
+    'run_failed',
+    'extract_source_started',
+    'extract_request_result',
+    'extract_decrypt_result',
+    'extract_iteration',
+    'extract_source_completed',
+    'extract_source_failed',
+    'speedtest_runtime',
+    'speedtest_probe_result',
+    'speedtest_selected',
+    'speedtest_result',
+    'speedtest_resume_state',
+    'resume_pipeline_state',
+    'availability_link_result'
+]);
+export function normalizeEvent(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Backend event must be an object');
+    }
+    const event = value;
+    if (typeof event.type !== 'string' || !event.type.trim()) {
+        throw new Error('Backend event is missing string type');
+    }
+    const normalized = { ...event, type: event.type.trim() };
+    return normalized;
+}
+export function parseEventLine(line) {
+    try {
+        return normalizeEvent(JSON.parse(line));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid backend event JSON: ${error.message}`);
+        }
+        throw error;
+    }
+}
+export function isKnownEventType(type) {
+    return KNOWN_EVENT_TYPES.has(type);
+}