claude-flow 3.32.2 → 3.32.8

package/v3/@claude-flow/cli/dist/src/commands/doctor.js

@@ -978,7 +978,7 @@ async function checkFunnel() {
     }
 }
 /** Meta LLM Proxy — sponsored-downtime health (ADR-313). */
-async function checkProxy() {
+async function checkProxySponsoredConsent() {
     try {
         const { funnelStateDir, hasConsent, readRateLimitStatus, lastRecordedEvent } = await import('../funnel/index.js');
         const dir = funnelStateDir();
@@ -1019,6 +1019,208 @@ async function checkProxy() {
         };
     }
 }
+/**
+ * Binary presence + tamper check (ADR-307). Deliberately NEVER spawns the
+ * binary to probe a version — confirmed empirically (2026-07-16) that
+ * `meta-proxy` has no `--version`/`--help` flag and starts the live server
+ * as a side effect of ANY invocation, which a doctor health check must never
+ * do. Version info instead comes from install-manifest.json (written at
+ * install time) and, once running, the proxy's own `/status` endpoint via
+ * checkProxyProcess below.
+ */
+async function checkProxyBinary() {
+    const NAME = 'Meta LLM Proxy binary (ADR-307)';
+    try {
+        const { proxyBinaryPath, proxyInstallManifestPath } = await import('../proxy/paths.js');
+        const binPath = proxyBinaryPath();
+        if (!existsSync(binPath)) {
+            return { name: NAME, status: 'warn', message: 'not installed', fix: 'ruflo proxy install' };
+        }
+        const manifestPath = proxyInstallManifestPath();
+        if (!existsSync(manifestPath)) {
+            return {
+                name: NAME,
+                status: 'warn',
+                message: 'binary present but no install-manifest.json — provenance unknown (installed outside `ruflo proxy install`?)',
+                fix: 'ruflo proxy update --release <x.y.z>',
+            };
+        }
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+        const liveSha = createHash('sha256').update(readFileSync(binPath)).digest('hex');
+        if (liveSha !== manifest.sha256) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: `binary sha256 does not match the recorded install manifest — possible tampering or a manual overwrite (expected ${manifest.sha256.slice(0, 12)}…, got ${liveSha.slice(0, 12)}…)`,
+                fix: 'ruflo proxy update --release <x.y.z>',
+            };
+        }
+        return { name: NAME, status: 'pass', message: `v${manifest.version}, signature-verified at install (${manifest.verifiedAt})` };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** PID-file liveness (ADR-307) — mirrors daemon.ts's signal-0 probe pattern. */
+async function checkProxyProcess() {
+    const NAME = 'Meta LLM Proxy process (ADR-307)';
+    try {
+        const { proxyPidFilePath } = await import('../proxy/paths.js');
+        const pidPath = proxyPidFilePath();
+        if (!existsSync(pidPath)) {
+            return { name: NAME, status: 'warn', message: 'not running (no PID file)', fix: 'ruflo proxy start' };
+        }
+        const pidRaw = readFileSync(pidPath, 'utf-8').trim();
+        const pid = parseInt(pidRaw, 10);
+        if (!Number.isFinite(pid)) {
+            return { name: NAME, status: 'warn', message: `PID file is malformed: ${JSON.stringify(pidRaw)}`, fix: 'ruflo proxy stop && ruflo proxy start' };
+        }
+        try {
+            process.kill(pid, 0); // signal-0 liveness probe — throws if the process is dead
+        }
+        catch {
+            return { name: NAME, status: 'warn', message: `PID file points at ${pid}, which is not running — stale PID file`, fix: 'ruflo proxy start' };
+        }
+        // Live version-compat + data-plane info, ONLY once PID liveness already
+        // confirmed a process is running (never spawns anything — see
+        // checkProxyBinary's comment on why probing via process launch is unsafe).
+        // GET /status shape confirmed against the real v0.1.0 binary:
+        // {"version","data_plane","bind","sponsored_available","proxy_token_valid"}.
+        const { proxyConfigPath, proxyTokenPath, proxyInstallManifestPath } = await import('../proxy/paths.js');
+        const bindMatch = existsSync(proxyConfigPath())
+            ? readFileSync(proxyConfigPath(), 'utf-8').match(/^bind\s*=\s*"([^"]*)"/m)
+            : null;
+        const bind = bindMatch ? bindMatch[1] : '127.0.0.1:11435';
+        let token;
+        try {
+            token = readFileSync(proxyTokenPath(), 'utf-8').trim();
+        }
+        catch {
+            return { name: NAME, status: 'pass', message: `running (pid ${pid}); no proxy-token to query /status` };
+        }
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 2000);
+            const resp = await fetch(`http://${bind}/status`, {
+                headers: { authorization: `Bearer ${token}` },
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!resp.ok) {
+                return { name: NAME, status: 'warn', message: `running (pid ${pid}); /status returned HTTP ${resp.status}` };
+            }
+            const body = (await resp.json());
+            let versionNote = '';
+            if (existsSync(proxyInstallManifestPath())) {
+                const manifest = JSON.parse(readFileSync(proxyInstallManifestPath(), 'utf-8'));
+                if (manifest.version && body.version && manifest.version !== body.version) {
+                    return {
+                        name: NAME,
+                        status: 'warn',
+                        message: `running (pid ${pid}) reports v${body.version}, but the installed binary is v${manifest.version} — a stale process from a previous version?`,
+                        fix: 'ruflo proxy stop && ruflo proxy start',
+                    };
+                }
+                versionNote = body.version ? ` v${body.version}` : '';
+            }
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `running (pid ${pid})${versionNote}; data plane: ${body.data_plane ?? 'unknown'}`,
+            };
+        }
+        catch (err) {
+            // Live process but /status unreachable (still starting up, or a
+            // network hiccup) — not a failure, PID liveness already passed.
+            return {
+                name: NAME,
+                status: 'pass',
+                message: `running (pid ${pid}); /status unreachable (${err instanceof Error ? err.message : String(err)})`,
+            };
+        }
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** Non-loopback bind exposure warning (ADR-307's mandated startup warning, surfaced in doctor too). */
+async function checkProxyBindAddress() {
+    const NAME = 'Meta LLM Proxy bind address (ADR-307)';
+    try {
+        const { proxyConfigPath, isLoopbackBind } = await import('../proxy/paths.js');
+        const cfgPath = proxyConfigPath();
+        if (!existsSync(cfgPath)) {
+            return { name: NAME, status: 'pass', message: 'no config file yet — defaults to loopback-only (127.0.0.1:11435)' };
+        }
+        const raw = readFileSync(cfgPath, 'utf-8');
+        const match = raw.match(/^bind\s*=\s*"([^"]*)"/m);
+        const bind = match ? match[1] : '127.0.0.1:11435';
+        if (!isLoopbackBind(bind)) {
+            return {
+                name: NAME,
+                status: 'warn',
+                message: `bound to non-loopback address ${bind} — this exposes the proxy to your network`,
+                fix: 'Set bind back to 127.0.0.1:<port> in proxy-config.toml unless external exposure is intended',
+            };
+        }
+        return { name: NAME, status: 'pass', message: `loopback-only (${bind})` };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** `ruflo auth` health (ADR-306). Warn (never fail) on absence — auth is never required for core functionality. */
+async function checkAuth() {
+    const NAME = 'Cognitum identity (ADR-306)';
+    try {
+        const { listProfiles } = await import('../auth/state.js');
+        const { domainForScope } = await import('../auth/scopes.js');
+        const { hasConsent } = await import('../funnel/index.js');
+        const { profiles } = listProfiles();
+        if (profiles.length === 0) {
+            return { name: NAME, status: 'warn', message: 'not logged in', fix: 'ruflo auth login' };
+        }
+        let keychainAvailable = 'unknown';
+        try {
+            const sec = await import('@claude-flow/security');
+            keychainAvailable = await (await sec.createKeychainAdapter()).isAvailable();
+        }
+        catch {
+            keychainAvailable = 'unknown'; // security package unavailable — surfaced by checkProxyBinary's sibling concerns, not duplicated here
+        }
+        // Scope-vs-receipt consistency check (ADR-306: "fail-closed... reports").
+        // Unlike every other check in this file, a violation here is a FAIL, not
+        // a warn — a scope present without a matching consent receipt is exactly
+        // the condition ADR-306 says must never silently pass.
+        const violations = [];
+        for (const p of profiles) {
+            for (const scope of p.scopes) {
+                const domain = domainForScope(scope);
+                if (domain && !hasConsent(domain))
+                    violations.push(`${p.profile}: ${scope}`);
+            }
+        }
+        if (violations.length > 0) {
+            return {
+                name: NAME,
+                status: 'fail',
+                message: `scope granted without a matching consent receipt: ${violations.join(', ')}`,
+                fix: 'ruflo auth logout && ruflo auth login',
+            };
+        }
+        const names = profiles.map((p) => p.profile).join(', ');
+        const sessionOnly = profiles.filter((p) => !p.keychainRef).map((p) => p.profile);
+        const parts = [`profiles: ${names}`];
+        if (keychainAvailable === false)
+            parts.push('keychain backend unreachable — falling back to session-only tokens');
+        if (sessionOnly.length > 0)
+            parts.push(`session-only (no persisted refresh token): ${sessionOnly.join(', ')}`);
+        return { name: NAME, status: 'pass', message: parts.join('; ') };
+    }
+    catch (err) {
+        return { name: NAME, status: 'warn', message: `check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
 async function checkMetaharnessIntegration() {
     // Locate plugins dir.
     //
@@ -1395,7 +1597,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, metaharness)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, agentic-flow, encryption, federation, funnel, proxy, auth, metaharness)',
             type: 'string'
         },
         {
@@ -1525,7 +1727,8 @@ export const doctorCommand = {
             checkMetaharness, // ADR-150 — MetaHarness upstream package
             checkMetaharnessIntegration, // iter 45 — ruflo-side integration layer
             checkFunnel, // ADR-305 — effective funnel state + deciding precedence source
-            checkProxy, // ADR-313 — Meta LLM Proxy sponsored-downtime health
+            checkProxySponsoredConsent, // ADR-313 — Meta LLM Proxy sponsored-downtime health
+            checkAuth, // ADR-306 — Cognitum identity (warn-only; never fails bare `ruflo doctor`)
         ];
         // #2677: `--component memory` now runs the whole memory-health suite,
         // not just the existence check. Values can be a single check or an
@@ -1563,7 +1766,11 @@ export const doctorCommand = {
             'metaharness': checkMetaharness, // ADR-150 — upstream package
             'metaharness-integration': checkMetaharnessIntegration, // iter 45 — ruflo-side
             'funnel': checkFunnel, // ADR-305
-            'proxy': checkProxy, // ADR-313
+            // ADR-307 — deep-dive array, same pattern as 'memory' above: the cheap
+            // sponsored-consent check first, then binary/process/bind in the order
+            // a user would actually debug them (is it installed? running? exposed?).
+            'proxy': [checkProxySponsoredConsent, checkProxyBinary, checkProxyProcess, checkProxyBindAddress],
+            'auth': checkAuth, // ADR-306
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

package/v3/@claude-flow/cli/dist/src/commands/index.js

@@ -79,6 +79,8 @@ const commandLoaders = {
     // User-facing preferences wrapper (ADR-311 copy discipline — no "funnel" in
     // the user surface). Forwards to the funnel primitives internally.
     settings: () => import('./settings.js'),
+    // Cognitum identity — login/logout/status (ADR-306)
+    auth: () => import('./auth.js'),
     // Meta LLM Proxy — sponsored downtime capacity (ADR-304/307/313)
     proxy: () => import('./proxy.js'),
     // Fable co-pilot advisor tip in the statusline insight ticker (ADR-316)

package/v3/@claude-flow/cli/dist/src/commands/proxy-lifecycle.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `ruflo proxy install|start|stop|status|logs|update|uninstall` (ADR-307) —
+ * the full lifecycle command set, kept in its own file so
+ * src/commands/proxy.ts (the ADR-313/314/315 consent subcommands) stays
+ * under the repo's 500-line-per-file convention. Merged into one
+ * `proxyCommand` in proxy.ts.
+ */
+import type { Command } from '../types.js';
+import { type ProxyStatus } from '../proxy/lifecycle.js';
+/** Pinned and reviewed; later upgrades remain explicit commands. */
+export declare const DEFAULT_PROXY_RELEASE = "0.4.0";
+/**
+ * Human-oriented next steps for `ruflo proxy` and `ruflo proxy status`.
+ * Keep this independent of the command framework so the state-specific
+ * guidance has a small, direct regression-test surface.
+ */
+export declare function proxyConsoleGuidance(status: ProxyStatus): string[];
+export declare function printProxyConsoleGuidance(status: ProxyStatus): void;
+export declare const proxyLifecycleSubcommands: Command[];
+//# sourceMappingURL=proxy-lifecycle.d.ts.map

package/v3/@claude-flow/cli/dist/src/commands/proxy-lifecycle.js

@@ -0,0 +1,277 @@
+/**
+ * `ruflo proxy install|start|stop|status|logs|update|uninstall` (ADR-307) —
+ * the full lifecycle command set, kept in its own file so
+ * src/commands/proxy.ts (the ADR-313/314/315 consent subcommands) stays
+ * under the repo's 500-line-per-file convention. Merged into one
+ * `proxyCommand` in proxy.ts.
+ */
+import { output } from '../output.js';
+import { hasConsent, recordConsent, revokeConsent } from '../funnel/index.js';
+import { installProxy, uninstallProxy } from '../proxy/install.js';
+import { startForeground, startBackground, stopProxy, getProxyStatus, readProxyLogTail, watchProxyLog, ProxyNotInstalledError, ProxyAlreadyRunningError, } from '../proxy/lifecycle.js';
+import { proxyTokenPath } from '../proxy/paths.js';
+import { removeInjectedToken, startTokenRefreshPump } from '../proxy/token-bridge.js';
+/** Pinned and reviewed; later upgrades remain explicit commands. */
+export const DEFAULT_PROXY_RELEASE = '0.4.0';
+const PROXY_COMMAND = 'npx ruflo@latest proxy';
+const AUTH_COMMAND = 'npx ruflo@latest auth';
+/**
+ * Human-oriented next steps for `ruflo proxy` and `ruflo proxy status`.
+ * Keep this independent of the command framework so the state-specific
+ * guidance has a small, direct regression-test surface.
+ */
+export function proxyConsoleGuidance(status) {
+    if (!status.installed) {
+        return [
+            '',
+            'Next step',
+            `  ${PROXY_COMMAND} install --yes    Install signed Meta-Proxy v${DEFAULT_PROXY_RELEASE}`,
+            '',
+            'After installation, start it in the background:',
+            `  ${PROXY_COMMAND} start --service`,
+        ];
+    }
+    if (!status.running) {
+        return [
+            '',
+            'Next step',
+            `  ${PROXY_COMMAND} start --service    Start the proxy in the background`,
+            '',
+            'Foreground mode (shows live logs; Ctrl+C stops it):',
+            `  ${PROXY_COMMAND} start`,
+            '',
+            'Optional: enable Cognitum cloud routing (local-only is the default):',
+            `  ${AUTH_COMMAND} login`,
+            `  ${PROXY_COMMAND} config --cloud --yes`,
+        ];
+    }
+    return [
+        '',
+        'Meta Proxy is ready.',
+        `  Logs:    ${PROXY_COMMAND} logs`,
+        `  Stop:    ${PROXY_COMMAND} stop`,
+        '',
+        'Optional: enable Cognitum cloud routing (local-only is the default):',
+        `  ${AUTH_COMMAND} login`,
+        `  ${PROXY_COMMAND} config --cloud --yes`,
+    ];
+}
+export function printProxyConsoleGuidance(status) {
+    for (const line of proxyConsoleGuidance(status))
+        output.writeln(line);
+}
+const INSTALL_DISCLOSURE = [
+    'Installing the Meta LLM Proxy (ADR-304/307).',
+    '',
+    'This downloads a separately-released Rust binary (Ed25519-signature and',
+    'checksum verified before anything is written to disk) and runs it as a',
+    'local process bound to 127.0.0.1 only. The proxy routes to LOCAL',
+    'backends by default — no prompt leaves this machine. Cloud routing is a',
+    'separate, explicit opt-in (`ruflo proxy config --cloud`), never enabled',
+    'by install alone.',
+    '',
+    'Uninstall anytime: ruflo proxy uninstall',
+].join('\n');
+const installSub = {
+    name: 'install',
+    description: 'Download, verify, and install the meta-proxy binary (ADR-307)',
+    options: [
+        // NOT named 'version' — index.ts:107 globally intercepts any --version/-v
+        // anywhere in argv (`if (flags.version || flags.V) { showVersion(); return; }`)
+        // BEFORE subcommand dispatch, regardless of which command defines it. A
+        // subcommand-local --version is silently swallowed by the CLI's own
+        // `ruflo --version` handling — confirmed the hard way in E2E testing.
+        { name: 'release', description: `Release version to install (default: ${DEFAULT_PROXY_RELEASE})`, type: 'string' },
+        { name: 'yes', description: 'Skip the confirmation prompt', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        // Resolve the reviewed default before the consent gate. An explicit empty
+        // override still fails below without recording a consent receipt.
+        const version = typeof ctx.flags.release === 'string' ? ctx.flags.release : DEFAULT_PROXY_RELEASE;
+        if (!version) {
+            output.printError('ruflo proxy install requires --release <x.y.z> — there is no version-discovery ' +
+                'endpoint yet (see the plan doc for the tracked follow-up). Find the latest at ' +
+                'the release channel and pass it explicitly.');
+            return { success: false, exitCode: 1 };
+        }
+        if (!hasConsent('proxy-install')) {
+            output.writeln(INSTALL_DISCLOSURE);
+            output.writeln('');
+            const confirmed = Boolean(ctx.flags.yes);
+            if (!confirmed) {
+                output.writeln(`Re-run with --yes to confirm: ruflo proxy install --yes (installs ${version})`);
+                return { success: true, data: { confirmed: false } };
+            }
+            recordConsent('proxy-install', true, 'proxy-install');
+        }
+        try {
+            const spinner = output.createSpinner({ text: `Installing meta-proxy ${version}...`, spinner: 'dots' });
+            spinner.start();
+            const result = await installProxy({ version, log: (line) => spinner.setText(line) });
+            spinner.succeed(`meta-proxy ${version} installed`);
+            output.writeln(`  binary: ${result.binaryPath}`);
+            output.writeln(`  sha256: ${result.sha256}`);
+            return { success: true, data: result };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Install failed', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const updateSub = {
+    name: 'update',
+    description: 'Re-verify and replace the installed binary with a specific version (never automatic)',
+    options: [{ name: 'release', description: 'Release version to install', type: 'string', required: true }],
+    action: async (ctx) => {
+        const version = typeof ctx.flags.release === 'string' ? ctx.flags.release : undefined;
+        if (!version) {
+            output.printError('ruflo proxy update requires --release <x.y.z>');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const spinner = output.createSpinner({ text: `Updating meta-proxy to ${version}...`, spinner: 'dots' });
+            spinner.start();
+            const result = await installProxy({ version, log: (line) => spinner.setText(line) });
+            spinner.succeed(`meta-proxy updated to ${version}`);
+            output.writeln(`  binary: ${result.binaryPath}`);
+            return { success: true, data: result };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Update failed', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const startSub = {
+    name: 'start',
+    description: 'Start meta-proxy (foreground by default; --service to detach)',
+    options: [
+        { name: 'service', description: 'Run detached (background), survives terminal close but not a reboot — full OS-service registration is not yet implemented', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        const service = Boolean(ctx.flags.service);
+        try {
+            if (service) {
+                const { pid } = await startBackground();
+                output.printSuccess(`meta-proxy started in the background (pid ${pid})`);
+                output.writeln('  Note: survives this terminal closing, but not a reboot — OS-service registration is not yet implemented.');
+                output.writeln('  Logs: ruflo proxy logs');
+                return { success: true, data: { pid } };
+            }
+            output.writeln('Starting meta-proxy in the foreground — press Ctrl+C to stop.');
+            await startTokenRefreshPump();
+            await startForeground(); // never returns normally
+            return { success: true };
+        }
+        catch (e) {
+            if (e instanceof ProxyNotInstalledError || e instanceof ProxyAlreadyRunningError) {
+                output.printError(e.message);
+                return { success: false, message: e.message, exitCode: 1 };
+            }
+            const message = e instanceof Error ? e.message : String(e);
+            output.printError('Failed to start meta-proxy', message);
+            return { success: false, message, exitCode: 1 };
+        }
+    },
+};
+const superviseSub = {
+    name: 'supervise',
+    description: 'Internal detached supervisor for token refresh and meta-proxy lifecycle',
+    action: async () => {
+        await startTokenRefreshPump();
+        await startForeground(true);
+        return { success: true };
+    },
+};
+const stopSub = {
+    name: 'stop',
+    description: 'Stop a running meta-proxy process',
+    action: async () => {
+        const result = await stopProxy();
+        removeInjectedToken();
+        if (!result.wasRunning) {
+            output.writeln('meta-proxy was not running.');
+            return { success: true, data: result };
+        }
+        output.printSuccess(`meta-proxy stopped (was pid ${result.pid})`);
+        return { success: true, data: result };
+    },
+};
+const statusSub = {
+    name: 'status',
+    description: 'Show meta-proxy install + process status',
+    options: [{ name: 'json', description: 'Machine-readable output', type: 'boolean', default: false }],
+    action: async (ctx) => {
+        const status = getProxyStatus();
+        if (ctx.flags.json) {
+            output.printJson(status);
+            return { success: true, data: status };
+        }
+        output.writeln('Meta Proxy');
+        output.writeln(`  Installation: ${status.installed ? 'ready' : 'not installed'}`);
+        output.writeln(`  Process: ${status.running ? `running (pid ${status.pid})` : 'not running'}`);
+        if (status.stalePidFile)
+            output.writeln('  (a stale PID file was found and will be cleared on next start)');
+        printProxyConsoleGuidance(status);
+        return { success: true, data: status };
+    },
+};
+const logsSub = {
+    name: 'logs',
+    description: 'Show meta-proxy --service logs',
+    options: [
+        { name: 'follow', short: 'f', description: 'Stream new log lines as they arrive', type: 'boolean', default: false },
+    ],
+    action: async (ctx) => {
+        if (ctx.flags.follow) {
+            output.writeln('Following meta-proxy logs — press Ctrl+C to stop.');
+            try {
+                const watcher = watchProxyLog((line) => output.writeln(line));
+                await new Promise((resolve) => {
+                    process.on('SIGINT', () => {
+                        watcher.close();
+                        resolve();
+                    });
+                });
+                return { success: true };
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                output.printError(message);
+                return { success: false, message, exitCode: 1 };
+            }
+        }
+        const tail = readProxyLogTail();
+        if (!tail) {
+            output.writeln('No log content yet — meta-proxy has never been started in --service mode.');
+            return { success: true, data: { empty: true } };
+        }
+        output.writeln(tail);
+        return { success: true };
+    },
+};
+const uninstallSub = {
+    name: 'uninstall',
+    description: 'Stop the proxy (if running), remove the binary, token, and consent receipt',
+    action: async () => {
+        const status = getProxyStatus();
+        if (status.running) {
+            await stopProxy();
+            output.writeln('Stopped the running meta-proxy process.');
+        }
+        const removed = await uninstallProxy();
+        const { existsSync, unlinkSync } = await import('node:fs');
+        const tokenPath = proxyTokenPath();
+        if (existsSync(tokenPath))
+            unlinkSync(tokenPath);
+        removeInjectedToken();
+        revokeConsent('proxy-install', 'proxy-uninstall');
+        output.printSuccess(removed ? 'meta-proxy uninstalled.' : 'Nothing was installed — cleaned up any leftover state.');
+        return { success: true, data: { removed } };
+    },
+};
+export const proxyLifecycleSubcommands = [installSub, updateSub, startSub, superviseSub, stopSub, statusSub, logsSub, uninstallSub];
+//# sourceMappingURL=proxy-lifecycle.js.map