@cortexkit/common-auth 0.1.0

package/dist/tui-build/walker.js

@@ -0,0 +1,171 @@
+/** Locate module strings without treating comments or ordinary strings as imports. */
+export function parseImports(code, filename) {
+    const tokens = [];
+    let position = 0;
+    const push = (start) => tokens.push({ text: code.slice(start, position), start, end: position });
+    const scan = (templateExpression = false) => {
+        let depth = 0;
+        while (position < code.length) {
+            const start = position;
+            const character = code.charAt(position);
+            if (/\s/.test(character)) {
+                position++;
+                continue;
+            }
+            if (code.startsWith('//', position)) {
+                position = code.indexOf('\n', position);
+                if (position < 0)
+                    position = code.length;
+                continue;
+            }
+            if (code.startsWith('/*', position)) {
+                const end = code.indexOf('*/', position + 2);
+                position = end < 0 ? code.length : end + 2;
+                continue;
+            }
+            if (character === '"' || character === "'") {
+                position++;
+                while (position < code.length) {
+                    const next = code[position++];
+                    if (next === '\\')
+                        position++;
+                    else if (next === character)
+                        break;
+                }
+                push(start);
+                continue;
+            }
+            if (character === '`') {
+                position++;
+                push(start);
+                while (position < code.length) {
+                    if (code[position] === '\\') {
+                        position += 2;
+                        continue;
+                    }
+                    if (code[position] === '`') {
+                        position++;
+                        break;
+                    }
+                    if (code.startsWith('${', position)) {
+                        position += 2;
+                        scan(true);
+                        continue;
+                    }
+                    position++;
+                }
+                continue;
+            }
+            // A regex body can contain import-shaped text that is not executable code.
+            const previous = tokens.at(-1)?.text;
+            if (character === '/' &&
+                (!previous ||
+                    [
+                        '=',
+                        '(',
+                        '[',
+                        '{',
+                        ',',
+                        ':',
+                        ';',
+                        'return',
+                        '=>',
+                        '!',
+                        '&&',
+                        '||',
+                    ].includes(previous))) {
+                position++;
+                let inClass = false;
+                while (position < code.length) {
+                    const next = code[position++];
+                    if (next === '\\') {
+                        position++;
+                        continue;
+                    }
+                    if (next === '[')
+                        inClass = true;
+                    if (next === ']')
+                        inClass = false;
+                    if (next === '/' && !inClass)
+                        break;
+                }
+                while (/[a-z]/i.test(code[position] ?? '') && position < code.length)
+                    position++;
+                push(start);
+                continue;
+            }
+            if (templateExpression && character === '}' && depth === 0) {
+                position++;
+                return;
+            }
+            if (character === '{')
+                depth++;
+            if (character === '}')
+                depth--;
+            if (/[\w$]/.test(character)) {
+                position++;
+                while (position < code.length && /[\w$]/.test(code.charAt(position)))
+                    position++;
+            }
+            else
+                position++;
+            push(start);
+        }
+    };
+    scan();
+    const references = [];
+    const add = (token) => {
+        if (!/^["']/.test(token.text))
+            return;
+        const specifier = token.text.slice(1, -1).replace(/\\(['"\\])/g, '$1');
+        references.push({ specifier, start: token.start, end: token.end });
+    };
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!token)
+            continue;
+        if (token.text !== 'import' && token.text !== 'export')
+            continue;
+        if (tokens[i - 1]?.text === '.')
+            continue;
+        const next = tokens[i + 1];
+        if (!next || next.text === '.')
+            continue;
+        if (token.text === 'import' && next.text === '(') {
+            const argument = tokens[i + 2];
+            if (!argument ||
+                !/^["']/.test(argument.text) ||
+                ![')', ','].includes(tokens[i + 3]?.text ?? '')) {
+                throw new Error(`Non-literal dynamic import in ${filename}: ${code.slice(next.end, code.indexOf(')', next.end))}`);
+            }
+            add(argument);
+        }
+        else if (/^["']/.test(next.text)) {
+            add(next);
+        }
+        else if (['{', '*', 'type'].includes(next.text) ||
+            token.text === 'import') {
+            for (let j = i + 1; j < tokens.length; j++) {
+                const candidate = tokens[j];
+                if (!candidate)
+                    continue;
+                if (candidate.text === ';' ||
+                    candidate.text === 'import' ||
+                    candidate.text === 'export')
+                    break;
+                if (candidate.text === 'from') {
+                    const source = tokens[j + 1];
+                    if (source)
+                        add(source);
+                    break;
+                }
+            }
+        }
+    }
+    return references;
+}
+export function isBareSpecifier(specifier) {
+    return (!specifier.startsWith('.') &&
+        !specifier.startsWith('/') &&
+        !specifier.includes(':'));
+}

package/dist/tui-prefs/index.d.ts

@@ -0,0 +1,2 @@
+export { createTuiPreferenceWriter, type PreferenceValue, readTuiPreferences, readTuiPreferencesFile, type TuiPreferencesReaderOptions, type TuiPreferenceWriter, type TuiPreferenceWriterOptions, } from './tui-preferences.js';
+export { type TuiPreferencesWatchOptions, watchTuiPreferences, } from './watcher.js';

package/dist/tui-prefs/index.js

@@ -0,0 +1,2 @@
+export { createTuiPreferenceWriter, readTuiPreferences, readTuiPreferencesFile, } from './tui-preferences.js';
+export { watchTuiPreferences, } from './watcher.js';

package/dist/tui-prefs/tui-preferences.d.ts

@@ -0,0 +1,25 @@
+/** Malformed or missing user-edited files are treated as an empty root. */
+export declare function readTuiPreferencesFile(file: string): Promise<Record<string, unknown>>;
+export interface TuiPreferencesReaderOptions<T> {
+    file: string;
+    pluginKey: string;
+    defaults: T;
+    /** The caller owns validation, clamping, and merging of its settings. */
+    schema: (entry: unknown, defaults: T) => T;
+}
+export declare function readTuiPreferences<T>(options: TuiPreferencesReaderOptions<T>): Promise<T>;
+export type PreferenceValue = string | number | boolean | null | PreferenceValue[] | {
+    [key: string]: PreferenceValue;
+};
+export interface TuiPreferenceWriterOptions {
+    file: string;
+    pluginKey: string;
+    timeoutMs?: number;
+    /** @internal Runs after staging, before the writer's ownership fence. */
+    beforeCommit?: () => Promise<void>;
+}
+export interface TuiPreferenceWriter {
+    queueTuiPreferenceUpdate(path: readonly (string | number)[], value: PreferenceValue): Promise<void>;
+}
+/** Each instance serializes updates; the file lock also excludes other processes. */
+export declare function createTuiPreferenceWriter(options: TuiPreferenceWriterOptions): TuiPreferenceWriter;

package/dist/tui-prefs/tui-preferences.js

@@ -0,0 +1,77 @@
+import { readFile } from 'node:fs/promises';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import { writeJsonAtomic } from '../fs/atomic-write.js';
+import { WRITER_LOCK_CONSTANTS } from '../fs/lock-constants.js';
+import { withLock } from '../fs/with-lock.js';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Malformed or missing user-edited files are treated as an empty root. */
+export async function readTuiPreferencesFile(file) {
+    try {
+        const errors = [];
+        const root = parse(await readFile(file, 'utf8'), errors, {
+            allowTrailingComma: true,
+        });
+        return errors.length === 0 && isRecord(root) ? root : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function readTuiPreferences(options) {
+    const root = await readTuiPreferencesFile(options.file);
+    const entry = Object.hasOwn(root, options.pluginKey)
+        ? root[options.pluginKey]
+        : undefined;
+    return options.schema(entry, options.defaults);
+}
+const TEMPLATE = `// Shared preferences for TUI plugins.
+// Plugins update individual keys in place and preserve comments.
+{}
+`;
+/** Each instance serializes updates; the file lock also excludes other processes. */
+export function createTuiPreferenceWriter(options) {
+    const { file, pluginKey, beforeCommit } = options;
+    const lockOptions = {
+        ...WRITER_LOCK_CONSTANTS.preferences,
+        timeoutMs: options.timeoutMs ?? WRITER_LOCK_CONSTANTS.preferences.timeoutMs,
+    };
+    let chain = Promise.resolve();
+    async function writePreference(path, value) {
+        await withLock(file, lockOptions, async (lock) => {
+            let text;
+            try {
+                text = await readFile(file, 'utf8');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                text = '';
+            }
+            if (text.trim() === '')
+                text = TEMPLATE;
+            const next = applyEdits(text, modify(text, [pluginKey, ...path], value, {
+                formattingOptions: { insertSpaces: true, tabSize: 2 },
+            }));
+            await writeJsonAtomic(file, next, {
+                serialize: (value) => String(value),
+                beforeRename: async () => {
+                    await beforeCommit?.();
+                    await lock.assertOwned();
+                },
+            });
+        });
+    }
+    return {
+        queueTuiPreferenceUpdate(path, value) {
+            // Snapshot inputs so queued callers cannot change an update before it runs.
+            const savedPath = [...path];
+            const savedValue = structuredClone(value);
+            const update = chain.then(() => writePreference(savedPath, savedValue));
+            // Recover only the stored tail; the caller still sees the original rejection.
+            chain = update.catch(() => { });
+            return update;
+        },
+    };
+}

package/dist/tui-prefs/watcher.d.ts

@@ -0,0 +1,6 @@
+import { watch } from 'node:fs';
+export interface TuiPreferencesWatchOptions {
+    watchDirectory?: typeof watch;
+}
+/** Watch the directory so atomic file replacement does not detach the watcher. */
+export declare function watchTuiPreferences(file: string, onChange: () => void, options?: TuiPreferencesWatchOptions): () => void;

package/dist/tui-prefs/watcher.js

@@ -0,0 +1,74 @@
+import { readFileSync, watch } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
+import { clearTimeout, setTimeout } from 'node:timers';
+/** Watch the directory so atomic file replacement does not detach the watcher. */
+export function watchTuiPreferences(file, onChange, options = {}) {
+    const name = basename(file);
+    let timer = null;
+    // An asynchronous seed could absorb a write made immediately after returning.
+    let lastSeen = null;
+    try {
+        lastSeen = readFileSync(file, 'utf8');
+    }
+    catch {
+        // Missing files can be created later.
+    }
+    let disposed = false;
+    const checkForChange = async () => {
+        const text = await readFile(file, 'utf8').catch(() => null);
+        if (disposed || text === null || text === lastSeen)
+            return;
+        lastSeen = text;
+        onChange();
+    };
+    const scheduleCheck = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            void checkForChange();
+        }, 150);
+    };
+    let watcher = null;
+    try {
+        watcher = (options.watchDirectory ?? watch)(dirname(file), (_event, filename) => {
+            const eventName = filename?.toString();
+            const isOurs = eventName === name ||
+                (eventName?.startsWith(`${name}.`) && eventName.endsWith('.tmp'));
+            if (eventName != null && !isOurs)
+                return;
+            scheduleCheck();
+        });
+        watcher.on('error', () => {
+            // Polling continues if the native watcher fails after construction.
+            watcher?.close();
+        });
+    }
+    catch {
+        if (lastSeen === null)
+            return () => { };
+    }
+    // Poll independently: directory watchers can miss rename events.
+    let pollTimer = null;
+    const schedulePoll = () => {
+        if (disposed || pollTimer)
+            return;
+        pollTimer = setTimeout(() => {
+            pollTimer = null;
+            if (disposed)
+                return;
+            void checkForChange().finally(schedulePoll);
+        }, 100);
+        pollTimer.unref();
+    };
+    schedulePoll();
+    return () => {
+        disposed = true;
+        if (timer)
+            clearTimeout(timer);
+        if (pollTimer)
+            clearTimeout(pollTimer);
+        watcher?.close();
+    };
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@cortexkit/common-auth",
+  "version": "0.1.0",
+  "description": "Shared plumbing for the CortexKit auth plugins: loopback RPC, file locks and atomic writes, logger, sidebar state file, TUI preferences and TUI build.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cortexkit/common-auth.git"
+  },
+  "type": "module",
+  "workspaces": [
+    "test/fixtures/*"
+  ],
+  "exports": {
+    "./rpc": {
+      "types": "./dist/rpc/index.d.ts",
+      "import": "./dist/rpc/index.js"
+    },
+    "./fs": {
+      "types": "./dist/fs/index.d.ts",
+      "import": "./dist/fs/index.js"
+    },
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "import": "./dist/logger/index.js"
+    },
+    "./sidebar-file": {
+      "types": "./dist/sidebar-file/index.d.ts",
+      "import": "./dist/sidebar-file/index.js"
+    },
+    "./tui-prefs": {
+      "types": "./dist/tui-prefs/index.d.ts",
+      "import": "./dist/tui-prefs/index.js"
+    },
+    "./tui-build": {
+      "types": "./dist/tui-build/index.d.ts",
+      "import": "./dist/tui-build/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui/index.d.ts",
+      "import": "./dist/tui/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "bun scripts/check-installed-ranges.mjs && tsc -p tsconfig.build.json",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "types": "bun run typecheck",
+    "format": "biome check --write --unsafe .",
+    "format:check": "biome format .",
+    "lint": "biome lint .",
+    "prepublishOnly": "bun run build",
+    "check:ranges": "bun scripts/check-installed-ranges.mjs"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.12",
+    "@opentui/solid": ">=0.5.12",
+    "solid-js": "1.9.12"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.14",
+    "@opentui/core": ">=0.5.12",
+    "@opentui/solid": ">=0.5.12",
+    "@tsconfig/bun": "1.0.11",
+    "@types/bun": "1.4.2",
+    "bun-types": "1.4.2",
+    "inline-default": "workspace:*",
+    "lefthook": "2.1.14",
+    "solid-js": "1.9.12",
+    "typescript": "7.0.2"
+  }
+}