@cortexkit/opencode-antigravity-auth 3.0.3 → 3.0.5

package/src/tui-raw/common-auth-embedded/fs/private-files.js

@@ -0,0 +1,302 @@
+import { randomUUID } from "node:crypto";
+import { lstat, readFile, rename, unlink } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export const windowsPrivateFiles = process.platform === 'win32';
+const migrationNotices = new Set();
+function ioCode(detail) {
+    // Native errors retain their Win32 code. Only demonstrated absence/exclusive
+    // collisions are normalized; access/sharing failures never become lost races.
+    if (detail?.reason === 'io-error') {
+        if (detail.win32Code === 2 || detail.win32Code === 3)
+            return 'ENOENT';
+        if (detail.win32Code === 80 || detail.win32Code === 183)
+            return 'EEXIST';
+    }
+    return detail?.code ?? 'ERR_PRIVATE_FILE';
+}
+// Production loads this package only on Windows; POSIX keeps its own directory policy.
+let backend;
+/** Tests inject a backend here; production always imports the private-files package. */
+export function setPrivateFilesBackendForTest(api) {
+    backend = api ? Promise.resolve(api) : undefined;
+}
+function loadBackend() {
+    backend ??= import("@cortexkit/private-files");
+    return backend;
+}
+export class PrivateFileError extends Error {
+    path;
+    stage;
+    code;
+    win32Code;
+    reason;
+    published = false;
+    durabilityConfirmed = false;
+    fileDurable = false;
+    attempts = 0;
+    elapsedMs = 0;
+    orphanPath;
+    constructor(path, stage, cause) {
+        const detail = cause;
+        super(`Private file refused at ${stage}: ${path} (${detail?.reason ?? detail?.code ?? 'io-error'}). Use a safe parent directory. Repair only a named secret file in safe ancestry whose owner the published policy trusts, without changing its owner or any existing directory. Previously exposed credentials may need rotation. Windows requires the private-files native prebuild and an ACL-persisting local filesystem such as NTFS.`, { cause });
+        this.path = path;
+        this.stage = stage;
+        this.name = 'PrivateFileError';
+        this.code = ioCode(detail);
+        this.win32Code = detail?.win32Code;
+        this.reason = detail?.reason;
+    }
+}
+export async function privateOperation(path, stage, operation) {
+    try {
+        return await operation();
+    }
+    catch (cause) {
+        if (cause instanceof PrivateFileError)
+            throw cause;
+        throw new PrivateFileError(path, stage, cause);
+    }
+}
+// Tests inject metadata into safe-parent checks, including checks deep inside
+// callers that take no policy options. Production never sets this.
+let safeParentOptionsForTest;
+/** Tests only: policy options used by safe-parent checks that pass none. */
+export function setSafeParentOptionsForTest(options) {
+    safeParentOptionsForTest = options;
+}
+/** Existing containing directories use the shared entry-integrity policy, not secret-file permissions. */
+export async function verifySafeDirectory(path, options) {
+    path = resolve(path);
+    options ??= safeParentOptionsForTest;
+    await privateOperation(path, 'safe-parent', async () => {
+        const result = await (await loadBackend()).verifySafeParent(path, options);
+        if (result.ok === false) {
+            // Preserve an absent parent's ENOENT so callers can create it privately.
+            if (result.reason === 'io-error' || result.reason === 'wrong-kind')
+                await lstat(path);
+            throw new PrivateFileError(result.level ?? result.path, 'safe-parent', {
+                ...result,
+                code: 'ERR_PRIVATE_FILES_SECURITY',
+            });
+        }
+    });
+}
+/** Repair only the specific owned secret file supplied by a caller, never an existing directory tree. */
+export async function verifyPrivate(path, kind, migrate = false) {
+    path = resolve(path);
+    if (kind === 'directory')
+        return verifySafeDirectory(path);
+    await privateOperation(path, 'verify', async () => {
+        const api = await loadBackend();
+        const result = await api.verifyOwnerOnly(path);
+        let repaired = false;
+        if (!result.ok) {
+            const { reason } = result.refusal;
+            // The result API intentionally omits native IO codes. Use the throwing
+            // API to preserve absence/collision details, never infer them from text.
+            if (reason === 'io-error')
+                await api.verifyPrivatePath(path, kind);
+            // DACL replacement repairs permissions only, never ownership or unsafe ancestry.
+            if (migrate &&
+                [
+                    api.EXTRA_ACE,
+                    api.NOT_PROTECTED,
+                    api.NULL_DACL,
+                    api.EMPTY_DACL,
+                ].includes(reason)) {
+                await verifySafeDirectory(dirname(path));
+                await api.securePrivatePath(path, kind);
+                repaired = true;
+            }
+            else {
+                throw Object.assign(new Error('Owner-only verification refused'), {
+                    reason,
+                    code: 'ERR_PRIVATE_FILES_SECURITY',
+                });
+            }
+        }
+        // Verify the expected object kind and its permissions by handle after repair.
+        await api.verifyPrivatePath(path, kind);
+        if (repaired && !migrationNotices.has(path)) {
+            migrationNotices.add(path);
+            process.emitWarning(`Private permissions tightened: ${path}. This object may have been readable before; rotate credentials if needed.`, 'PrivateFileMigration');
+        }
+    });
+}
+/** Create missing components privately; inspect existing ancestors without modifying them. */
+export async function ensurePrivateDirectory(path, _migrate = false, options) {
+    path = resolve(path);
+    await privateOperation(path, 'directory', async () => {
+        const api = await loadBackend();
+        try {
+            await lstat(path);
+            return await verifySafeDirectory(path, options);
+        }
+        catch (error) {
+            if (ioCode(error) !== 'ENOENT')
+                throw error;
+        }
+        const parent = dirname(path);
+        if (parent === path)
+            throw Object.assign(new Error('Missing root'), { code: 'ENOENT' });
+        await ensurePrivateDirectory(parent, false, options);
+        try {
+            await api.createOwnerOnly(path, { kind: 'dir' });
+        }
+        catch (error) {
+            if (ioCode(error) !== 'EEXIST')
+                throw error;
+        }
+        await verifySafeDirectory(path, options);
+    });
+}
+export async function readPrivateText(path, migrate = false) {
+    if (!windowsPrivateFiles)
+        return readFile(path, 'utf8');
+    return (await readPrivateBuffer(path, migrate)).toString('utf8');
+}
+export async function readPrivateBuffer(path, migrate = false) {
+    if (!windowsPrivateFiles)
+        return readFile(path);
+    path = resolve(path);
+    if (migrate) {
+        await verifySafeDirectory(dirname(path));
+        await verifyPrivate(path, 'file', true);
+    }
+    return privateOperation(path, 'read', async () => (await loadBackend()).readOwnerOnly(path));
+}
+export async function createPrivateBytes(path, bytes) {
+    await verifySafeDirectory(dirname(resolve(path)));
+    await privateOperation(path, 'create', async () => {
+        // The backend verifies the creation handle while empty, before consuming bytes.
+        await (await loadBackend()).createPrivateFile(resolve(path), bytes);
+    });
+}
+export async function createPrivateDirectoryExclusive(path) {
+    await verifySafeDirectory(dirname(resolve(path)));
+    await privateOperation(path, 'directory-create', async () => {
+        await (await loadBackend()).createOwnerOnly(resolve(path), { kind: 'dir' });
+    });
+}
+/** Retry Windows rename sharing/access errors within a budget; they never prove lease contention. */
+export async function replaceWindowsFile(from, to, options = {}) {
+    from = resolve(from);
+    to = resolve(to);
+    const now = options.now ?? (() => performance.now());
+    const start = now();
+    const deadline = Math.min(start + 500, options.deadline ?? Infinity);
+    const delays = [0, 10, 20, 40, 80, 100];
+    let original;
+    let attempts = 0;
+    for (const delay of delays) {
+        if (now() >= deadline)
+            break;
+        if (delay)
+            await (options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(Math.min(delay, Math.max(0, deadline - now())));
+        if (now() >= deadline)
+            break;
+        await options.beforeRename?.();
+        if (now() >= deadline)
+            break;
+        attempts++;
+        try {
+            await (options.rename ?? rename)(from, to);
+            return { attempts, elapsedMs: now() - start };
+        }
+        catch (error) {
+            original ??= error;
+            const detail = error;
+            const candidate = detail.win32Code !== undefined
+                ? detail.win32Code === 32 || detail.win32Code === 33
+                : ['EBUSY', 'EPERM', 'EACCES'].includes(detail.code ?? '') &&
+                    !detail.reason;
+            if (!candidate)
+                break;
+        }
+    }
+    const error = new PrivateFileError(to, 'rename', original ??
+        Object.assign(new Error('Publication deadline expired'), {
+            code: 'ETIMEDOUT',
+        }));
+    error.attempts = attempts;
+    error.elapsedMs = now() - start;
+    throw error;
+}
+export async function writePrivateAtomic(path, bytes, options = {}) {
+    path = resolve(path);
+    await ensurePrivateDirectory(dirname(path));
+    try {
+        await verifyPrivate(path, 'file', true);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const stage = resolve(options.stagePath ?? `${path}.${randomUUID()}.tmp`);
+    if (dirname(stage) !== dirname(path))
+        throw new PrivateFileError(path, 'stage-directory', { code: 'EXDEV' });
+    let created = false;
+    let published = false;
+    let outcome = { attempts: 0, elapsedMs: 0 };
+    let stageName = 'stage-create';
+    const reportOutcome = (error) => {
+        try {
+            options.onOutcome?.({
+                path,
+                stage: error?.stage ?? 'published',
+                published,
+                fileDurable: published,
+                durabilityConfirmed: false,
+                attempts: error?.attempts ?? outcome.attempts,
+                elapsedMs: error?.elapsedMs ?? outcome.elapsedMs,
+                ...(error && { code: error.code, win32Code: error.win32Code }),
+            });
+        }
+        catch {
+            // Outcome observers cannot change whether publication succeeded.
+        }
+    };
+    try {
+        await createPrivateBytes(stage, bytes);
+        created = true;
+        stageName = 'before-rename';
+        outcome = await replaceWindowsFile(stage, path, options);
+        created = false;
+        published = true;
+        stageName = 'published-callback';
+        options.onRenamed?.();
+        stageName = 'published-verify';
+        await verifyPrivate(path, 'file');
+        // createPrivateFile flushes the file. Directory metadata durability has not
+        // been qualified on Windows, so never promise the POSIX directory fsync.
+        if (options.durable && options.durability !== 'file-only-on-windows')
+            throw new PrivateFileError(path, 'directory-sync-unsupported', {
+                code: 'ENOTSUP',
+            });
+        reportOutcome();
+    }
+    catch (cause) {
+        const error = cause instanceof PrivateFileError
+            ? cause
+            : new PrivateFileError(path, stageName, cause);
+        error.published = published;
+        error.fileDurable = published;
+        if (published)
+            Object.assign(error, outcome);
+        if (created) {
+            try {
+                await unlink(stage);
+            }
+            catch {
+                error.orphanPath = stage;
+            }
+            created = false;
+        }
+        reportOutcome(error);
+        throw error;
+    }
+    finally {
+        if (created)
+            await unlink(stage).catch(() => { });
+    }
+}

package/src/tui-raw/common-auth-embedded/logger/engine.js

@@ -1,4 +1,7 @@
 import { appendFileSync, chmodSync, existsSync, renameSync, statSync, } from "node:fs";
+import { open } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { createPrivateBytes, ensurePrivateDirectory, privateOperation, replaceWindowsFile, verifyPrivate, windowsPrivateFiles, } from "../fs/private-files.js";
 import { createRedactor } from "./redact.js";
 const ORDER = {
     error: 0,
@@ -36,6 +39,75 @@ function rotateIfNeeded(f) {
         /* never throw */
     }
 }
+async function closeWindowsFile(sink) {
+    const { file, handle } = sink;
+    sink.file = undefined;
+    sink.handle = undefined;
+    if (file && handle)
+        await privateOperation(file, 'log-close', () => handle.close());
+}
+async function openWindowsFile(sink, file) {
+    await ensurePrivateDirectory(dirname(file));
+    try {
+        await verifyPrivate(file, 'file', true);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        try {
+            await createPrivateBytes(file, '');
+        }
+        catch (creationError) {
+            if (creationError.code !== 'EEXIST')
+                throw creationError;
+            await verifyPrivate(file, 'file', true);
+        }
+    }
+    // The safe-parent policy denies other ordinary users the ability to create, replace or link entries between verification and fs.open.
+    // This protects against other ordinary users, not the owner or administrators, whose ability to change that namespace is outside our threat model.
+    sink.handle = await privateOperation(file, 'log-open', () => open(file, 'a'));
+    sink.file = file;
+    return sink.handle;
+}
+async function flushWindowsFile(sink, file, text) {
+    file = resolve(file);
+    try {
+        if (sink.file !== file)
+            await closeWindowsFile(sink);
+        let handle = sink.handle ?? (await openWindowsFile(sink, file));
+        const info = await privateOperation(file, 'log-stat', () => handle.stat());
+        if (info.size >= MAX_BYTES) {
+            await closeWindowsFile(sink);
+            for (let i = ROTATE_KEEP - 1; i >= 0; i--) {
+                const source = i === 0 ? file : `${file}.${i}`;
+                const target = `${file}.${i + 1}`;
+                try {
+                    await verifyPrivate(source, 'file', true);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                try {
+                    await verifyPrivate(target, 'file', true);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                await replaceWindowsFile(source, target);
+                await verifyPrivate(target, 'file');
+            }
+            handle = await openWindowsFile(sink, file);
+        }
+        await privateOperation(file, 'log-append', () => handle.appendFile(text, 'utf8'));
+    }
+    catch (error) {
+        await closeWindowsFile(sink).catch(() => { });
+        throw error;
+    }
+}
 function safeSerialize(data) {
     try {
         return ` ${JSON.stringify(data)}`;
@@ -63,7 +135,19 @@ function createEngine(options) {
     let captureSink;
     let buffer = [];
     let timer;
+    let orderedSink = Promise.resolve();
+    let sinkError;
+    const windowsFile = {};
+    function queueWindows(operation) {
+        const next = orderedSink.then(operation);
+        orderedSink = next.catch((error) => {
+            sinkError = error;
+        });
+        return next;
+    }
     function configure(next) {
+        if (windowsPrivateFiles && next.file !== logFileSource)
+            void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => { });
         logFileSource = next.file;
         initLevelSource = next.level;
         redactor = createRedactor(next);
@@ -89,25 +173,49 @@ function createEngine(options) {
             return floor;
         return 'info';
     }
-    function flushLogs() {
+    function flushLogs(close = true) {
         if (timer) {
             clearTimeout(timer);
             timer = undefined;
         }
-        if (!buffer.length)
+        if (!buffer.length) {
+            if (windowsPrivateFiles)
+                return queueWindows(async () => {
+                    if (close)
+                        await closeWindowsFile(windowsFile);
+                    if (sinkError)
+                        throw sinkError;
+                });
             return;
+        }
         let file;
         try {
             file = logFilePath();
         }
         catch {
             buffer = [];
+            if (windowsPrivateFiles && close)
+                return queueWindows(() => closeWindowsFile(windowsFile));
             return;
         }
         const text = buffer.join('');
         buffer = [];
-        if (!file)
+        if (!file) {
+            if (windowsPrivateFiles && close)
+                return queueWindows(() => closeWindowsFile(windowsFile));
             return;
+        }
+        if (windowsPrivateFiles) {
+            return queueWindows(async () => {
+                try {
+                    await flushWindowsFile(windowsFile, file, text);
+                }
+                finally {
+                    if (close)
+                        await closeWindowsFile(windowsFile);
+                }
+            });
+        }
         try {
             rotateIfNeeded(file);
             if (existsSync(file))
@@ -122,7 +230,9 @@ function createEngine(options) {
         if (!timer)
             timer = setTimeout(() => {
                 timer = undefined;
-                flushLogs();
+                const flushed = flushLogs(false);
+                if (flushed instanceof Promise)
+                    void flushed.catch(() => { });
             }, 500);
     }
     function emit(channel, level, message, data) {
@@ -157,8 +267,11 @@ function createEngine(options) {
             if (logFileSource === undefined)
                 return;
             buffer.push(line);
-            if (buffer.length >= 50)
-                flushLogs();
+            if (buffer.length >= 50) {
+                const flushed = flushLogs(false);
+                if (flushed instanceof Promise)
+                    void flushed.catch(() => { });
+            }
             else
                 schedule();
         }
@@ -176,6 +289,9 @@ function createEngine(options) {
         };
     }
     function reset() {
+        if (windowsPrivateFiles)
+            void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => { });
+        sinkError = undefined;
         buffer = [];
         if (timer) {
             clearTimeout(timer);
@@ -222,18 +338,17 @@ export function setLogLevel(l) {
     defaultEngine.setLogLevel(l);
 }
 /**
- * Write whatever the default logger has buffered. Safe to call synchronously
- * from a process-exit handler, which is how each host drains the buffer on
- * shutdown.
+ * Write whatever the default logger has buffered. On Windows await the
+ * promise before shutdown; POSIX keeps synchronous process-exit flushing.
  */
 export function flushLogs() {
-    defaultEngine.flushLogs();
+    return defaultEngine.flushLogs();
 }
 export function createLogger(channel) {
     return defaultEngine.createLogger(channel);
 }
 export async function flushForTest() {
-    defaultEngine.flushLogs();
+    return defaultEngine.flushLogs();
 }
 /**
  * Return the default logger to its uninitialised state. Only a test needs

package/src/tui-raw/common-auth-embedded/rpc/port-file.js

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
-import { chmod, mkdir, open, readdir, readFile, rename, rmdir, stat, unlink, } from "node:fs/promises";
+import { chmod, mkdir, open, readdir, rename, rmdir, stat, unlink, } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { ensurePrivateDirectory, PrivateFileError, readPrivateText, verifyPrivate, windowsPrivateFiles, writePrivateAtomic, } from "../fs/private-files.js";
 /**
  * A PID a liveness probe may address. `process.kill(0 | negative, 0)` signals
  * a process group rather than a process, and an unsafe integer cannot name a
@@ -68,6 +69,15 @@ export async function writePortFile(dir, entry, options = {}) {
     // persistent ENOENT (e.g. permission, read-only parent) will surface on
     // the second attempt — failing fast beats an unbounded loop.
     const writeOnce = async () => {
+        const target = join(dir, `port-${entry.pid}.json`);
+        if (windowsPrivateFiles) {
+            await ensurePrivateDirectory(dir, options.secureDir ?? false);
+            await options.beforeWrite?.();
+            await writePrivateAtomic(target, JSON.stringify({ ...entry, startedAt: Date.now() }), {
+                stagePath: `${target}.${(options.stageName ?? randomUUID)()}.tmp`,
+            });
+            return target;
+        }
         await mkdir(dir, {
             recursive: true,
             mode: options.secureDir ? 0o700 : undefined,
@@ -76,7 +86,6 @@ export async function writePortFile(dir, entry, options = {}) {
             await chmod(dir, 0o700);
         await options.beforeWrite?.();
         const full = { ...entry, startedAt: Date.now() };
-        const target = join(dir, `port-${entry.pid}.json`);
         const tmp = `${target}.${(options.stageName ?? randomUUID)()}.tmp`;
         let handle;
         let created = false;
@@ -139,9 +148,11 @@ export async function sweepRpcState(root, activeDir, isManagedDir, log) {
             const portFile = join(dir, name);
             let raw;
             try {
-                raw = await readFile(portFile, 'utf8');
+                raw = await readPrivateText(portFile);
             }
-            catch {
+            catch (error) {
+                if (error instanceof PrivateFileError && error.code !== 'ENOENT')
+                    throw error;
                 continue;
             }
             if (raw === undefined)
@@ -172,19 +183,27 @@ export async function portFileIdentity(dir, entry) {
         return null;
     const path = join(resolve(dir), `port-${entry.pid}.json`);
     try {
+        if (windowsPrivateFiles)
+            await verifyPrivate(path, 'file');
         const info = await stat(path);
         return `${path}:${info.dev}:${info.ino}:${info.mtimeMs}:${info.size}`;
     }
-    catch {
+    catch (error) {
+        if (error instanceof PrivateFileError && error.code !== 'ENOENT')
+            throw error;
         return null;
     }
 }
 export async function discoverPortFile(dir, expectedPid, options = {}) {
     let names;
     try {
+        if (windowsPrivateFiles)
+            await verifyPrivate(dir, 'directory');
         names = await readdir(dir);
     }
-    catch {
+    catch (error) {
+        if (error instanceof PrivateFileError && error.code !== 'ENOENT')
+            throw error;
         return null;
     }
     const live = [];
@@ -192,7 +211,7 @@ export async function discoverPortFile(dir, expectedPid, options = {}) {
         if (!name.startsWith('port-') || !name.endsWith('.json'))
             continue;
         try {
-            const parsed = JSON.parse(await readFile(join(dir, name), 'utf8'));
+            const parsed = JSON.parse(await readPrivateText(join(dir, name)));
             if (isUsablePortFileEntry(parsed, name)) {
                 if (pidAlive(parsed.pid))
                     live.push(parsed);
@@ -200,7 +219,10 @@ export async function discoverPortFile(dir, expectedPid, options = {}) {
                     await unlink(join(dir, name)).catch(() => { });
             }
         }
-        catch { }
+        catch (error) {
+            if (error instanceof PrivateFileError && error.code !== 'ENOENT')
+                throw error;
+        }
     }
     if (live.length === 0)
         return null;

package/src/tui-raw/common-auth-embedded/rpc/rpc-client.js

@@ -1,6 +1,7 @@
 import { open } from "node:fs/promises";
 import { connect } from "node:net";
 import { join, resolve } from "node:path";
+import { readPrivateText, windowsPrivateFiles } from "../fs/private-files.js";
 import { discoverPortFile, portFileIdentity, } from "./port-file.js";
 export const DEFAULT_RPC_TIMEOUT_MS = 2_000;
 const selections = new Map();
@@ -12,6 +13,17 @@ const discoveries = new Map();
 // those bytes still name the discovered entry.
 async function boundIdentity(dir, entry) {
     const path = join(resolve(dir), `port-${entry.pid}.json`);
+    if (windowsPrivateFiles) {
+        const current = JSON.parse(await readPrivateText(path));
+        if (current.pid !== entry.pid ||
+            current.port !== entry.port ||
+            current.token !== entry.token)
+            return null;
+        // private-files does not expose the read handle's identity, so a separate
+        // stat cannot bind an RPC-server cache entry to the file that supplied its
+        // token. On Windows, rediscover the port file on every call.
+        return null;
+    }
     let handle;
     try {
         handle = await open(path, 'r');
@@ -32,7 +44,9 @@ async function boundIdentity(dir, entry) {
 }
 async function select(key, dir, expectedPid, options) {
     const cached = selections.get(key);
-    if (cached && (await portFileIdentity(dir, cached.entry)) === cached.identity)
+    if (!windowsPrivateFiles &&
+        cached &&
+        (await portFileIdentity(dir, cached.entry)) === cached.identity)
         return cached;
     selections.delete(key);
     const pending = discoveries.get(key);