claude-flow 3.32.1 → 3.32.8

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

@@ -0,0 +1,249 @@
+/**
+ * meta-proxy process lifecycle (ADR-307) — start/stop/status/logs.
+ *
+ * Adapts daemon.ts's proven pattern (PID file, O_EXCL lockfile for atomic
+ * check-then-start, signal-0 liveness, SIGTERM->1000ms->SIGKILL) to a
+ * native binary instead of a forked Node process. The binary itself takes
+ * no CLI flags — confirmed empirically (2026-07-16): `meta-proxy.exe` has
+ * no `--version`/`--help`, and any invocation just starts the server reading
+ * its own config file — so `spawn()` here passes zero arguments, always.
+ *
+ * Foreground `start` (the ADR-307 default) uses `stdio: 'inherit'` and
+ * blocks directly — simplest and safest, no log-file redirection needed.
+ * `start --service` needs REAL file-descriptor redirection
+ * (`stdio: ['ignore', fd, fd]`) + `detached: true` + `unref()` via
+ * `child_process.spawn()` directly — `SafeExecutor.executeStreaming()`
+ * buffers output in-process, which is wrong for a process meant to outlive
+ * the `ruflo` invocation that started it.
+ *
+ * @module proxy/lifecycle
+ */
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import { proxyBinaryPath, proxyPidFilePath, proxyLockFilePath, proxyLogFilePath } from './paths.js';
+export class ProxyNotInstalledError extends Error {
+    constructor() {
+        super('meta-proxy is not installed. Run: ruflo proxy install');
+        this.name = 'ProxyNotInstalledError';
+    }
+}
+export class ProxyAlreadyRunningError extends Error {
+    pid;
+    constructor(pid) {
+        super(`meta-proxy is already running (pid ${pid}). Stop it first with: ruflo proxy stop`);
+        this.pid = pid;
+        this.name = 'ProxyAlreadyRunningError';
+    }
+}
+function requireBinary() {
+    const bin = proxyBinaryPath();
+    if (!fs.existsSync(bin))
+        throw new ProxyNotInstalledError();
+    return bin;
+}
+/** Signal-0 liveness probe — cross-platform in Node, throws if the process is dead. */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getProxyStatus() {
+    const installed = fs.existsSync(proxyBinaryPath());
+    const pidPath = proxyPidFilePath();
+    if (!fs.existsSync(pidPath)) {
+        return { installed, running: false, pid: null, stalePidFile: false };
+    }
+    const raw = fs.readFileSync(pidPath, 'utf-8').trim();
+    const pid = parseInt(raw, 10);
+    if (!Number.isFinite(pid)) {
+        return { installed, running: false, pid: null, stalePidFile: true };
+    }
+    const running = isProcessRunning(pid);
+    return { installed, running, pid: running ? pid : null, stalePidFile: !running };
+}
+function writePidFile(pid) {
+    fs.writeFileSync(proxyPidFilePath(), String(pid), 'utf-8');
+}
+function clearStalePidFile() {
+    try {
+        fs.unlinkSync(proxyPidFilePath());
+    }
+    catch {
+        // already absent
+    }
+}
+/**
+ * Atomic check-then-start via an O_EXCL lockfile — the same fix daemon.ts
+ * applies for the identical race (#2407/#2484: without this, N concurrent
+ * `start` calls all see "not running" and all spawn their own process).
+ * Returns the lock fd to release once the PID file has been written (or on
+ * any early-return/throw), never before.
+ */
+function acquireStartLock() {
+    const lockFile = proxyLockFilePath();
+    try {
+        return fs.openSync(lockFile, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+    }
+    catch (e) {
+        if (e.code === 'EEXIST')
+            return null; // another start is mid-spawn
+        throw e;
+    }
+}
+function releaseStartLock(fd) {
+    if (fd === null)
+        return;
+    try {
+        fs.closeSync(fd);
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        fs.unlinkSync(proxyLockFilePath());
+    }
+    catch {
+        /* ignore */
+    }
+}
+/**
+ * Foreground start (ADR-307 default) — blocks the caller until the process
+ * exits or is interrupted. `stdio: 'inherit'` passes the proxy's own output
+ * straight through to the terminal; signals (Ctrl+C) propagate naturally to
+ * the child, no manual forwarding needed.
+ */
+export async function startForeground(supervised = false) {
+    const bin = requireBinary();
+    const status = getProxyStatus();
+    // In service mode startBackground has already written this supervisor's
+    // PID. Treating it as a competing proxy makes the supervisor immediately
+    // exit before it can spawn meta-proxy.
+    if (!supervised && status.running && status.pid)
+        throw new ProxyAlreadyRunningError(status.pid);
+    if (status.stalePidFile)
+        clearStalePidFile();
+    const child = spawn(bin, [], { stdio: 'inherit', windowsHide: false });
+    if (!supervised && child.pid)
+        writePidFile(child.pid);
+    const cleanup = () => clearStalePidFile();
+    process.on('exit', cleanup);
+    if (supervised) {
+        const forwardSignal = (signal) => {
+            if (!child.killed)
+                child.kill(signal);
+        };
+        process.once('SIGTERM', () => forwardSignal('SIGTERM'));
+        process.once('SIGINT', () => forwardSignal('SIGINT'));
+    }
+    await new Promise((resolve) => {
+        child.on('exit', () => {
+            cleanup();
+            resolve();
+        });
+    });
+    process.exit(0);
+}
+/**
+ * Background/`--service` start — detaches so the process outlives this
+ * `ruflo` invocation, redirecting stdout/stderr to a real log file (not
+ * buffered in-process). Returns once the child's PID is confirmed written,
+ * without waiting for the process to exit.
+ */
+export async function startBackground() {
+    requireBinary();
+    const status = getProxyStatus();
+    if (status.running && status.pid)
+        throw new ProxyAlreadyRunningError(status.pid);
+    const lockFd = acquireStartLock();
+    try {
+        // Re-check under the lock — the dedup above raced a concurrent starter.
+        const rechecked = getProxyStatus();
+        if (rechecked.running && rechecked.pid)
+            throw new ProxyAlreadyRunningError(rechecked.pid);
+        if (rechecked.stalePidFile)
+            clearStalePidFile();
+        const logFd = fs.openSync(proxyLogFilePath(), 'a');
+        const cliEntry = process.argv[1];
+        if (!cliEntry)
+            throw new Error('cannot locate the ruflo CLI entrypoint for supervised service mode');
+        const child = spawn(process.execPath, [cliEntry, 'proxy', 'supervise'], {
+            stdio: ['ignore', logFd, logFd],
+            detached: true,
+            windowsHide: true,
+        });
+        fs.closeSync(logFd); // the child holds its own duplicated fd; safe to close ours
+        if (!child.pid)
+            throw new Error('ruflo proxy supervisor failed to spawn — no PID returned');
+        writePidFile(child.pid);
+        child.unref();
+        return { pid: child.pid };
+    }
+    finally {
+        releaseStartLock(lockFd);
+    }
+}
+/** SIGTERM -> 1000ms -> SIGKILL if still alive, mirroring daemon.ts's killBackgroundDaemon. */
+export async function stopProxy() {
+    const status = getProxyStatus();
+    if (!status.running || !status.pid) {
+        if (status.stalePidFile)
+            clearStalePidFile();
+        return { wasRunning: false, pid: null };
+    }
+    const pid = status.pid;
+    process.kill(pid, 'SIGTERM');
+    await new Promise((r) => setTimeout(r, 1000));
+    if (isProcessRunning(pid)) {
+        process.kill(pid, 'SIGKILL');
+    }
+    clearStalePidFile();
+    return { wasRunning: true, pid };
+}
+const TAIL_BYTES = 64 * 1024; // bounded read — a long-running proxy's log grows over weeks
+export function readProxyLogTail(maxBytes = TAIL_BYTES) {
+    const logPath = proxyLogFilePath();
+    if (!fs.existsSync(logPath))
+        return '';
+    const { size } = fs.statSync(logPath);
+    const start = Math.max(0, size - maxBytes);
+    const fd = fs.openSync(logPath, 'r');
+    try {
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        return buf.toString('utf-8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** Streams new log lines as they're appended, starting from the current end of file. */
+export function watchProxyLog(onLine) {
+    const logPath = proxyLogFilePath();
+    if (!fs.existsSync(logPath)) {
+        throw new Error('no log file yet — meta-proxy has never been started in --service mode');
+    }
+    let offset = fs.statSync(logPath).size;
+    return fs.watch(logPath, () => {
+        const { size } = fs.statSync(logPath);
+        if (size <= offset)
+            return;
+        const fd = fs.openSync(logPath, 'r');
+        try {
+            const buf = Buffer.alloc(size - offset);
+            fs.readSync(fd, buf, 0, buf.length, offset);
+            offset = size;
+            for (const line of buf.toString('utf-8').split('\n')) {
+                if (line.length > 0)
+                    onLine(line);
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    });
+}
+//# sourceMappingURL=lifecycle.js.map

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

@@ -0,0 +1,34 @@
+/**
+ * Filesystem layout for the managed meta-proxy binary (ADR-307), all under
+ * the same `~/.ruflo` state dir every other funnel/proxy/auth file uses
+ * (src/funnel/state.ts's `funnelStateDir()` — respects RUFLO_STATE_DIR for
+ * tests). Centralized here so doctor.ts, install.ts, and lifecycle.ts share
+ * one definition instead of three copies drifting apart.
+ */
+export declare function proxyBinaryPath(): string;
+export declare function proxyPidFilePath(): string;
+export declare function proxyLockFilePath(): string;
+export declare function proxyLogFilePath(): string;
+export declare function proxyInstallManifestPath(): string;
+export declare function proxyConfigPath(): string;
+export declare function proxyTokenPath(): string;
+export declare function proxyInjectedTokenPath(): string;
+export interface InstallManifest {
+    version: string;
+    sha256: string;
+    verifiedAt: string;
+    pubkeyFingerprint: string;
+}
+/**
+ * True if `bind` (a `host:port` string from proxy-config.toml) targets a
+ * loopback address — decides whether the non-loopback exposure warning
+ * fires (ADR-307). Recognizes the whole IPv4 127.0.0.0/8 block, IPv6 `::1`,
+ * IPv4-mapped IPv6 loopback, and the `localhost` hostname.
+ *
+ * A plain `bind.startsWith('127.0.0.1')` check (the obvious first draft)
+ * misclassifies `[::1]:port` as non-loopback — a real bug meta-proxy's own
+ * Rust `is_loopback_bind` fixed for the identical reason; this mirrors that
+ * fix rather than repeating the mistake on the TypeScript side.
+ */
+export declare function isLoopbackBind(bind: string): boolean;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1,70 @@
+/**
+ * Filesystem layout for the managed meta-proxy binary (ADR-307), all under
+ * the same `~/.ruflo` state dir every other funnel/proxy/auth file uses
+ * (src/funnel/state.ts's `funnelStateDir()` — respects RUFLO_STATE_DIR for
+ * tests). Centralized here so doctor.ts, install.ts, and lifecycle.ts share
+ * one definition instead of three copies drifting apart.
+ */
+import { join } from 'node:path';
+import { funnelStateDir } from '../funnel/index.js';
+const BINARY_NAME = process.platform === 'win32' ? 'meta-proxy.exe' : 'meta-proxy';
+export function proxyBinaryPath() {
+    return join(funnelStateDir(), 'bin', BINARY_NAME);
+}
+export function proxyPidFilePath() {
+    return join(funnelStateDir(), 'proxy.pid');
+}
+export function proxyLockFilePath() {
+    return join(funnelStateDir(), 'proxy.lock');
+}
+export function proxyLogFilePath() {
+    return join(funnelStateDir(), 'proxy.log');
+}
+export function proxyInstallManifestPath() {
+    return join(funnelStateDir(), 'proxy', 'install-manifest.json');
+}
+export function proxyConfigPath() {
+    return join(funnelStateDir(), 'proxy-config.toml');
+}
+export function proxyTokenPath() {
+    return join(funnelStateDir(), 'proxy-token');
+}
+export function proxyInjectedTokenPath() {
+    return join(funnelStateDir(), 'proxy-injected-token.json');
+}
+/**
+ * True if `bind` (a `host:port` string from proxy-config.toml) targets a
+ * loopback address — decides whether the non-loopback exposure warning
+ * fires (ADR-307). Recognizes the whole IPv4 127.0.0.0/8 block, IPv6 `::1`,
+ * IPv4-mapped IPv6 loopback, and the `localhost` hostname.
+ *
+ * A plain `bind.startsWith('127.0.0.1')` check (the obvious first draft)
+ * misclassifies `[::1]:port` as non-loopback — a real bug meta-proxy's own
+ * Rust `is_loopback_bind` fixed for the identical reason; this mirrors that
+ * fix rather than repeating the mistake on the TypeScript side.
+ */
+export function isLoopbackBind(bind) {
+    const hostPart = (host) => {
+        const stripped = host.replace(/^\[/, '').replace(/\]$/, '');
+        if (stripped.toLowerCase() === 'localhost')
+            return true;
+        if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(stripped))
+            return true; // 127.0.0.0/8
+        if (stripped === '::1')
+            return true;
+        if (/^::ffff:127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/i.test(stripped))
+            return true; // IPv4-mapped loopback
+        return false;
+    };
+    // IPv6 bracketed form: [::1]:11435
+    const bracketed = bind.match(/^\[([^\]]+)\]:\d+$/);
+    if (bracketed)
+        return hostPart(bracketed[1]);
+    // host:port (IPv4 or hostname) — split on the LAST colon so a bare IPv6
+    // address without brackets (ambiguous, shouldn't occur in practice) isn't
+    // misparsed as host:port.
+    const lastColon = bind.lastIndexOf(':');
+    const host = lastColon === -1 ? bind : bind.slice(0, lastColon);
+    return hostPart(host);
+}
+//# sourceMappingURL=paths.js.map

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

@@ -0,0 +1,47 @@
+/**
+ * meta-proxy release resolution + download (ADR-307).
+ *
+ * Two download paths, deliberately not conflated:
+ * - **Production** (`downloadReleaseAsset`): public, signed assets from
+ *   cognitum-one/meta-proxy-dist. Source remains private; normal users need
+ *   neither GitHub authentication nor access to the source repository.
+ * - **Dev-only** (`downloadViaGhCli`): shells out to `gh release download`,
+ *   gated behind `RUFLO_DEV_PROXY_INSTALL=1` so it is never reachable by
+ *   accident, and always logs loudly that it is a developer path.
+ *
+ * @module proxy/release
+ */
+export declare const TARGET_TRIPLES: readonly ["aarch64-apple-darwin", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "x86_64-pc-windows-msvc"];
+export type TargetTriple = (typeof TARGET_TRIPLES)[number];
+export declare class UnsupportedPlatformError extends Error {
+    constructor(platform: string, arch: string);
+}
+/** Maps the running Node process's platform/arch onto one of meta-proxy's 5 published triples. */
+export declare function detectTargetTriple(platform?: string, arch?: string): TargetTriple;
+export declare function releaseArchiveExtension(triple: TargetTriple): 'zip' | 'tar.gz';
+export declare function releaseAssetFilename(version: string, triple: TargetTriple): string;
+export interface ReleaseAssets {
+    archiveBytes: Buffer;
+    archiveFilename: string;
+    sumsBytes: Buffer;
+    sigBase64: string;
+}
+/**
+ * Dev-only fallback: `gh release download` via SafeExecutor into `destDir`.
+ * Requires the caller's environment to already have `gh` authenticated
+ * against a GitHub account with access to the private meta-proxy repo — this
+ * is NOT something a normal ruflo end user has, which is exactly why this
+ * path is gated and logged, not the default.
+ */
+export declare function downloadViaGhCli(destDir: string, version: string, triple: TargetTriple, log?: (line: string) => void): Promise<ReleaseAssets>;
+/**
+ * Production download path — a Cognitum-owned, auth-mediated release-proxy
+ * endpoint. Not implemented: no such endpoint exists in the confirmed
+ * OpenAPI contract today. Throws a clear, specific error rather than
+ * silently falling back to the dev path, so a real user hitting this isn't
+ * left guessing whether it's their environment or a genuine gap.
+ */
+export declare function downloadReleaseAsset(version: string, triple: TargetTriple, _destDir: string): Promise<ReleaseAssets>;
+/** Entry point install.ts calls — routes to the dev path when explicitly enabled, else fails clearly. */
+export declare function fetchReleaseAssets(version: string, triple: TargetTriple, destDir: string, log?: (line: string) => void): Promise<ReleaseAssets>;
+//# sourceMappingURL=release.d.ts.map

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

@@ -0,0 +1,138 @@
+/**
+ * meta-proxy release resolution + download (ADR-307).
+ *
+ * Two download paths, deliberately not conflated:
+ * - **Production** (`downloadReleaseAsset`): public, signed assets from
+ *   cognitum-one/meta-proxy-dist. Source remains private; normal users need
+ *   neither GitHub authentication nor access to the source repository.
+ * - **Dev-only** (`downloadViaGhCli`): shells out to `gh release download`,
+ *   gated behind `RUFLO_DEV_PROXY_INSTALL=1` so it is never reachable by
+ *   accident, and always logs loudly that it is a developer path.
+ *
+ * @module proxy/release
+ */
+export const TARGET_TRIPLES = [
+    'aarch64-apple-darwin',
+    'x86_64-apple-darwin',
+    'x86_64-unknown-linux-gnu',
+    'aarch64-unknown-linux-gnu',
+    'x86_64-pc-windows-msvc',
+];
+export class UnsupportedPlatformError extends Error {
+    constructor(platform, arch) {
+        super(`meta-proxy has no published release for ${platform}/${arch}`);
+        this.name = 'UnsupportedPlatformError';
+    }
+}
+/** Maps the running Node process's platform/arch onto one of meta-proxy's 5 published triples. */
+export function detectTargetTriple(platform = process.platform, arch = process.arch) {
+    if (platform === 'darwin')
+        return arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    if (platform === 'linux')
+        return arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';
+    if (platform === 'win32') {
+        if (arch !== 'x64')
+            throw new UnsupportedPlatformError(platform, arch);
+        return 'x86_64-pc-windows-msvc';
+    }
+    throw new UnsupportedPlatformError(platform, arch);
+}
+export function releaseArchiveExtension(triple) {
+    return triple.endsWith('windows-msvc') ? 'zip' : 'tar.gz';
+}
+export function releaseAssetFilename(version, triple) {
+    return `meta-proxy-${version}-${triple}.${releaseArchiveExtension(triple)}`;
+}
+const DEV_INSTALL_ENV = 'RUFLO_DEV_PROXY_INSTALL';
+const RELEASE_SOURCE_ENV = 'RUFLO_PROXY_RELEASE_SOURCE';
+const GH_REPO = 'cognitum-one/meta-proxy';
+const PUBLIC_DIST_BASE = 'https://github.com/cognitum-one/meta-proxy-dist/releases/download';
+const MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+async function downloadPublicAsset(url, maxBytes) {
+    const response = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(120_000) });
+    if (!response.ok)
+        throw new Error(`release download failed: HTTP ${response.status} for ${url}`);
+    const declared = Number(response.headers.get('content-length') ?? 0);
+    if (declared > maxBytes)
+        throw new Error(`release asset exceeds ${maxBytes} byte limit`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > maxBytes)
+        throw new Error(`release asset exceeds ${maxBytes} byte limit`);
+    return bytes;
+}
+async function ghExecutor() {
+    // Dynamic import, not a static one: @claude-flow/security is only an
+    // optionalDependency of this package (see auth/security-bridge.ts for the
+    // same reasoning) — a static top-level import would crash module load for
+    // any consumer that doesn't have it installed, even ones that never touch
+    // this dev-only download path.
+    const { SafeExecutor } = await import('@claude-flow/security');
+    return new SafeExecutor({ allowedCommands: ['gh'], timeout: 120_000 });
+}
+/**
+ * Dev-only fallback: `gh release download` via SafeExecutor into `destDir`.
+ * Requires the caller's environment to already have `gh` authenticated
+ * against a GitHub account with access to the private meta-proxy repo — this
+ * is NOT something a normal ruflo end user has, which is exactly why this
+ * path is gated and logged, not the default.
+ */
+export async function downloadViaGhCli(destDir, version, triple, log = () => { }) {
+    const archiveFilename = releaseAssetFilename(version, triple);
+    log(`[dev-only] Downloading meta-proxy ${version} (${triple}) via \`gh release download\` — ` +
+        'this path is NOT how production installs work; it exists for local development only ' +
+        `(gated behind ${DEV_INSTALL_ENV}=1).`);
+    const exec = await ghExecutor();
+    const result = await exec.execute('gh', [
+        'release',
+        'download',
+        `v${version}`,
+        '--repo',
+        GH_REPO,
+        '--dir',
+        destDir,
+        '--pattern',
+        archiveFilename,
+        '--pattern',
+        'SHA256SUMS',
+        '--pattern',
+        'SHA256SUMS.sig',
+        '--clobber',
+    ]);
+    if (result.exitCode !== 0) {
+        throw new Error(`gh release download failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    const { readFile } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    const [archiveBytes, sumsBytes, sigRaw] = await Promise.all([
+        readFile(join(destDir, archiveFilename)),
+        readFile(join(destDir, 'SHA256SUMS')),
+        readFile(join(destDir, 'SHA256SUMS.sig'), 'utf-8'),
+    ]);
+    return { archiveBytes, archiveFilename, sumsBytes, sigBase64: sigRaw.trim() };
+}
+/**
+ * Production download path — a Cognitum-owned, auth-mediated release-proxy
+ * endpoint. Not implemented: no such endpoint exists in the confirmed
+ * OpenAPI contract today. Throws a clear, specific error rather than
+ * silently falling back to the dev path, so a real user hitting this isn't
+ * left guessing whether it's their environment or a genuine gap.
+ */
+export async function downloadReleaseAsset(version, triple, _destDir) {
+    const archiveFilename = releaseAssetFilename(version, triple);
+    const base = (process.env[RELEASE_SOURCE_ENV] || PUBLIC_DIST_BASE).replace(/\/$/, '');
+    const release = `${base}/v${encodeURIComponent(version)}`;
+    const [archiveBytes, sumsBytes, sigBytes] = await Promise.all([
+        downloadPublicAsset(`${release}/${archiveFilename}`, MAX_ARCHIVE_BYTES),
+        downloadPublicAsset(`${release}/SHA256SUMS`, 128 * 1024),
+        downloadPublicAsset(`${release}/SHA256SUMS.sig`, 16 * 1024),
+    ]);
+    return { archiveBytes, archiveFilename, sumsBytes, sigBase64: sigBytes.toString('utf8').trim() };
+}
+/** Entry point install.ts calls — routes to the dev path when explicitly enabled, else fails clearly. */
+export async function fetchReleaseAssets(version, triple, destDir, log) {
+    if (process.env[DEV_INSTALL_ENV] === '1') {
+        return downloadViaGhCli(destDir, version, triple, log);
+    }
+    return downloadReleaseAsset(version, triple, destDir);
+}
+//# sourceMappingURL=release.js.map

package/v3/@claude-flow/cli/dist/src/proxy/token-bridge.d.ts

@@ -0,0 +1,5 @@
+/** ADR-318 access-token-only bridge from ruflo auth to meta-proxy. */
+export declare function removeInjectedToken(): void;
+export declare function refreshInjectedToken(): Promise<boolean>;
+export declare function startTokenRefreshPump(): Promise<() => void>;
+//# sourceMappingURL=token-bridge.d.ts.map

package/v3/@claude-flow/cli/dist/src/proxy/token-bridge.js

@@ -0,0 +1,61 @@
+/** ADR-318 access-token-only bridge from ruflo auth to meta-proxy. */
+import * as fs from 'node:fs';
+import { dirname } from 'node:path';
+import { getValidAccessToken } from '../auth/client.js';
+import { getProfile, listProfiles } from '../auth/state.js';
+import { proxyConfigPath, proxyInjectedTokenPath } from './paths.js';
+const REFRESH_POLL_MS = 30_000;
+function configureInjectedTokenPath() {
+    const target = proxyConfigPath();
+    fs.mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+    const raw = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : '';
+    const line = `ruflo_injected_token_path = ${JSON.stringify(proxyInjectedTokenPath())}`;
+    const pattern = /^ruflo_injected_token_path\s*=.*$/m;
+    const next = pattern.test(raw) ? raw.replace(pattern, line) : `${raw}${raw && !raw.endsWith('\n') ? '\n' : ''}${line}\n`;
+    const tmp = `${target}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, next, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, target);
+}
+export function removeInjectedToken() {
+    try {
+        fs.unlinkSync(proxyInjectedTokenPath());
+    }
+    catch { /* absent */ }
+}
+export async function refreshInjectedToken() {
+    const { defaultProfile } = listProfiles();
+    const profile = getProfile(defaultProfile);
+    if (!profile) {
+        removeInjectedToken();
+        return false;
+    }
+    try {
+        const accessToken = await getValidAccessToken(defaultProfile);
+        const current = getProfile(defaultProfile);
+        if (!current)
+            return false;
+        const body = JSON.stringify({ schemaVersion: 1, accessToken, expiresAt: current.accessTokenExpiresAt });
+        configureInjectedTokenPath();
+        const target = proxyInjectedTokenPath();
+        const tmp = `${target}.tmp-${process.pid}`;
+        fs.writeFileSync(tmp, body, { encoding: 'utf8', mode: 0o600 });
+        fs.chmodSync(tmp, 0o600);
+        fs.renameSync(tmp, target);
+        return true;
+    }
+    catch {
+        removeInjectedToken();
+        return false;
+    }
+}
+export async function startTokenRefreshPump() {
+    await refreshInjectedToken();
+    const timer = setInterval(() => void refreshInjectedToken(), REFRESH_POLL_MS);
+    const stop = () => {
+        clearInterval(timer);
+        removeInjectedToken();
+    };
+    process.once('exit', removeInjectedToken);
+    return stop;
+}
+//# sourceMappingURL=token-bridge.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * meta-proxy release verification (ADR-307) — mirrors src/init/helper-signing.ts's
+ * raw-EdDSA `crypto.verify(null, ...)` pattern almost exactly, and matches the
+ * exact scheme confirmed live 2026-07-16 against a real v0.1.0 release: ONE
+ * combined `SHA256SUMS.sig` (raw Ed25519 over the `SHA256SUMS` file's bytes,
+ * base64-encoded — not a per-binary signature), then a per-asset SHA-256
+ * check against the matching `SHA256SUMS` line. Refuse-all-or-nothing on any
+ * mismatch, same discipline as `writeCriticalHelpers()`.
+ *
+ * @module proxy/verify
+ */
+/**
+ * meta-proxy's committed release-signing public key (SPKI PEM), confirmed
+ * live 2026-07-16 by verifying a real `SHA256SUMS.sig` from the v0.1.0
+ * release against it (crypto.verify -> true).
+ */
+export declare const PROXY_RELEASE_PUBKEY_PEM = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAjhLDomjIGdcltYC7j+aiESQFD4LWoHaULietG1PuDjw=\n-----END PUBLIC KEY-----";
+export declare class ReleaseVerificationError extends Error {
+    constructor(message: string);
+}
+/** Raw EdDSA verify of `SHA256SUMS.sig` (base64) over `SHA256SUMS`'s exact bytes. */
+export declare function verifySha256SumsSignature(sumsBytes: Buffer, sigBase64: string, pubkeyPem?: string): boolean;
+export type ParsedChecksums = Record<string, string>;
+/** Parses `<sha256>  <filename>` lines (sha256sum's own output format). */
+export declare function parseSha256Sums(sumsText: string): ParsedChecksums;
+export declare function sha256Hex(bytes: Buffer): string;
+export interface VerifyReleaseInput {
+    sumsBytes: Buffer;
+    sigBase64: string;
+    assetBytes: Buffer;
+    assetFilename: string;
+    pubkeyPem?: string;
+}
+export interface VerifyReleaseResult {
+    sha256: string;
+}
+/**
+ * Full verification: signature over SHA256SUMS, then the asset's own hash
+ * against the matching line. Throws `ReleaseVerificationError` on ANY
+ * failure — there is no partial-trust outcome, matching ADR-307's "refuses
+ * on any mismatch" requirement.
+ */
+export declare function verifyRelease(input: VerifyReleaseInput): VerifyReleaseResult;
+//# sourceMappingURL=verify.d.ts.map