@kruntime/komputer 0.1.0

package/dist/drive.js

@@ -0,0 +1,656 @@
+import { KState, normalizeKPath } from "./kstate.js";
+import { joinPath, relativePath } from "./path.js";
+export const MOUNT_REGISTRY_PATH = '/meta/mounts.jsonl';
+export function ro(source) {
+    return { kind: 'mount-binding', source, mode: 'ro' };
+}
+export function rw(source) {
+    return { kind: 'mount-binding', source, mode: 'rw' };
+}
+export class MountTable {
+    entries = new Map();
+    constructor(rootDrive) {
+        this.mount('/', rootDrive);
+    }
+    mount(path, drive, options = {}) {
+        const kPath = normalizeKPath(path);
+        if (this.entries.has(kPath))
+            throw new Error(`drive already mounted at ${kPath}`);
+        const mode = options.mode ?? 'rw';
+        this.entries.set(kPath, { drive, mode, mounted: false });
+    }
+    has(path) {
+        return this.entries.has(normalizeKPath(path));
+    }
+    async unmount(path) {
+        const kPath = normalizeKPath(path);
+        const entry = this.entries.get(kPath);
+        if (!entry)
+            return;
+        this.entries.delete(kPath);
+        if (!entry.mounted)
+            return;
+        await entry.drive.unmount?.();
+        entry.mounted = false;
+    }
+    async activate() {
+        for (const [path, entry] of this.entries.entries()) {
+            if (entry.mounted)
+                continue;
+            await entry.drive.mount?.({
+                path,
+                mode: entry.mode,
+            });
+            entry.mounted = true;
+        }
+    }
+    async unmountAll() {
+        const entries = [...this.entries.values()].reverse();
+        for (const entry of entries) {
+            if (!entry.mounted)
+                continue;
+            await entry.drive.unmount?.();
+            entry.mounted = false;
+        }
+    }
+    list() {
+        return [...this.entries.entries()]
+            .map(([path, entry]) => ({ path, drive: entry.drive, mode: entry.mode }))
+            .sort((a, b) => a.path.localeCompare(b.path));
+    }
+    childMounts(path) {
+        const parent = normalizeKPath(path);
+        return this.list().filter((entry) => {
+            if (entry.path === '/' || entry.path === parent)
+                return false;
+            return dirnameOf(entry.path) === parent;
+        });
+    }
+    hasDescendant(path) {
+        const parent = normalizeKPath(path);
+        const prefix = parent === '/' ? '/' : `${parent}/`;
+        return this.list().some((entry) => entry.path !== parent && entry.path.startsWith(prefix));
+    }
+    resolve(path) {
+        const kPath = normalizeKPath(path);
+        const matches = [...this.entries.entries()]
+            .filter(([mountPath]) => kPath === mountPath || kPath.startsWith(`${mountPath.replace(/\/$/, '')}/`) || mountPath === '/')
+            .sort((a, b) => b[0].length - a[0].length);
+        const [mountPath, entry] = matches[0] ?? [];
+        if (!mountPath || !entry)
+            throw new Error(`no drive mounted for path: ${kPath}`);
+        const drive = entry.drive;
+        const drivePath = mountPath === '/'
+            ? kPath
+            : `/${relativePath(mountPath, kPath)}`;
+        return { mountPath, drivePath: normalizeKPath(drivePath), drive, mode: entry.mode };
+    }
+    realPath(path) {
+        const resolved = this.resolve(path);
+        return resolved.drive.realPath?.(resolved.drivePath);
+    }
+}
+function dirnameOf(path) {
+    const normalized = normalizeKPath(path);
+    if (normalized === '/')
+        return '/';
+    const index = normalized.lastIndexOf('/');
+    return index <= 0 ? '/' : normalized.slice(0, index);
+}
+export function basenameOf(path) {
+    const normalized = normalizeKPath(path);
+    if (normalized === '/')
+        return '/';
+    return normalized.slice(normalized.lastIndexOf('/') + 1);
+}
+export class KStateDrive {
+    kind = 'drive';
+    name;
+    prefix;
+    kstate;
+    constructor(kstate, { name = 'kstate', prefix = '/' } = {}) {
+        this.kstate = kstate;
+        this.name = name;
+        this.prefix = normalizeKPath(prefix);
+    }
+    async readText(path) {
+        return this.kstate.readText(this.fullPath(path));
+    }
+    async writeText(path, text) {
+        await this.kstate.writeText(this.fullPath(path), text);
+    }
+    async mkdir(path) {
+        await this.kstate.mkdir(this.fullPath(path));
+    }
+    async rm(path, options = {}) {
+        await this.kstate.rm(this.fullPath(path), options);
+    }
+    async rename(from, to) {
+        await this.kstate.rename(this.fullPath(from), this.fullPath(to));
+    }
+    async symlink(target, path) {
+        await this.kstate.symlink(target, this.fullPath(path));
+    }
+    async readLink(path) {
+        return this.kstate.readLink(this.fullPath(path));
+    }
+    async chmod(path, mode) {
+        await this.kstate.chmod(this.fullPath(path), mode);
+    }
+    async utime(path, mtime) {
+        await this.kstate.utime(this.fullPath(path), mtime);
+    }
+    async exists(path) {
+        return this.kstate.exists(this.fullPath(path));
+    }
+    async readdir(path) {
+        return this.kstate.readdir(this.fullPath(path));
+    }
+    async stat(path) {
+        return this.kstate.stat(this.fullPath(path));
+    }
+    fullPath(path = '/') {
+        const subPath = normalizeKPath(path);
+        return this.prefix === '/'
+            ? subPath
+            : normalizeKPath(joinPath(this.prefix, subPath.slice(1)));
+    }
+    realPath(path = '/') {
+        return this.kstate.realRootPath(this.fullPath(path));
+    }
+}
+export async function recordMount(kstate, record) {
+    await kstate.appendJsonl(MOUNT_REGISTRY_PATH, { ...record, path: normalizeKPath(record.path) });
+}
+export async function readMountRegistry(kstate) {
+    const rows = await kstate.readJsonl(MOUNT_REGISTRY_PATH);
+    const latest = new Map();
+    for (const row of rows) {
+        const legacy = row;
+        const mode = legacy.mode === 'ro' || legacy.mode === 'rw'
+            ? legacy.mode
+            : legacy.readonly ? 'ro' : 'rw';
+        latest.set(normalizeKPath(row.path), { ...row, mode, path: normalizeKPath(row.path) });
+    }
+    return [...latest.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+export class OverlayDrive {
+    kind = 'drive';
+    name;
+    lower;
+    upper;
+    constructor({ name = 'overlay', lower, upper }) {
+        this.name = name;
+        this.lower = lower;
+        this.upper = upper;
+    }
+    async readText(path) {
+        if (await this.isDeleted(path))
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        if (await this.upper.exists(path))
+            return this.upper.readText(path);
+        return this.lower.readText(path);
+    }
+    async writeText(path, text) {
+        await this.clearTombstone(path);
+        await this.upper.writeText(path, text);
+    }
+    async mkdir(path) {
+        await this.clearTombstone(path);
+        await this.upper.mkdir(path);
+    }
+    async rm(path, options = {}) {
+        await this.upper.rm(path, { recursive: true, force: true }).catch(() => undefined);
+        if (!(await this.lower.exists(path)) && !options.force)
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        await this.upper.writeText(this.tombstonePath(path), JSON.stringify({ deletedAt: new Date().toISOString(), path: normalizeKPath(path) }));
+    }
+    async rename(from, to) {
+        const stat = await this.stat(from);
+        if (stat.type !== 'file')
+            throw new Error('overlay rename currently supports files; copy directory contents explicitly');
+        const text = await this.readText(from);
+        await this.writeText(to, text);
+        await this.rm(from, { force: true });
+    }
+    async symlink(target, path) {
+        await this.clearTombstone(path);
+        if (!this.upper.symlink)
+            throw new Error(`drive ${this.upper.name} does not support symlink`);
+        await this.upper.symlink(target, path);
+    }
+    async readLink(path) {
+        if (await this.isDeleted(path))
+            return undefined;
+        const upperTarget = await this.upper.readLink?.(path);
+        if (upperTarget !== undefined)
+            return upperTarget;
+        return this.lower.readLink?.(path);
+    }
+    async chmod(path, mode) {
+        await this.clearTombstone(path);
+        if (await this.upper.exists(path)) {
+            await this.upper.chmod(path, mode);
+            return;
+        }
+        if (!(await this.lower.exists(path)))
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        const stat = await this.lower.stat?.(path);
+        if (stat?.type === 'symlink') {
+            const target = await this.lower.readLink?.(path);
+            if (target === undefined)
+                throw new Error(`file not found: ${normalizeKPath(path)}`);
+            await this.chmod(resolveRelativeDrivePath(path, target), mode);
+            return;
+        }
+        if (stat?.type === 'dir') {
+            await this.upper.mkdir(path);
+            await this.upper.chmod(path, mode);
+            return;
+        }
+        const text = await this.lower.readText(path);
+        await this.upper.writeText(path, text);
+        await this.upper.chmod(path, mode);
+    }
+    async utime(path, mtime) {
+        await this.clearTombstone(path);
+        if (await this.upper.exists(path)) {
+            await this.upper.utime(path, mtime);
+            return;
+        }
+        if (!(await this.lower.exists(path)))
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        const stat = await this.lower.stat?.(path);
+        if (stat?.type === 'symlink') {
+            const target = await this.lower.readLink?.(path);
+            if (target === undefined)
+                throw new Error(`file not found: ${normalizeKPath(path)}`);
+            await this.utime(resolveRelativeDrivePath(path, target), mtime);
+            return;
+        }
+        if (stat?.type === 'dir') {
+            await this.upper.mkdir(path);
+            await this.upper.utime(path, mtime);
+            return;
+        }
+        const text = await this.lower.readText(path);
+        await this.upper.writeText(path, text);
+        await this.upper.utime(path, mtime);
+    }
+    async exists(path) {
+        if (await this.isDeleted(path))
+            return false;
+        return (await this.upper.exists(path)) || this.lower.exists(path);
+    }
+    async readdir(path) {
+        if (await this.isDeleted(path))
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        const entries = new Map();
+        const lowerEntries = await this.lower.readdir(path).catch(() => []);
+        const upperEntries = await this.upper.readdir(path).catch(() => []);
+        for (const entry of lowerEntries)
+            entries.set(entry.name, entry.type);
+        for (const entry of upperEntries) {
+            if (entry.name === '.k-overlay')
+                continue;
+            entries.set(entry.name, entry.type);
+        }
+        for (const entry of [...entries.keys()]) {
+            if (await this.isDeleted(joinPath(path, entry)))
+                entries.delete(entry);
+        }
+        return [...entries.entries()].map(([name, type]) => ({ name, type }));
+    }
+    async stat(path) {
+        if (await this.isDeleted(path))
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        if (await this.upper.exists(path))
+            return this.upper.stat(path);
+        if (!this.lower.stat) {
+            if (await this.lower.exists(path))
+                return { type: 'file' };
+            throw new Error(`file not found: ${normalizeKPath(path)}`);
+        }
+        return this.lower.stat(path);
+    }
+    tombstonePath(path) {
+        return normalizeKPath(joinPath('/.k-overlay/tombstones', encodeURIComponent(normalizeKPath(path))));
+    }
+    async clearTombstone(path) {
+        await this.upper.rm(this.tombstonePath(path), { force: true }).catch(() => undefined);
+    }
+    async isDeleted(path) {
+        let current = normalizeKPath(path);
+        while (current !== '/') {
+            if (await this.upper.exists(this.tombstonePath(current)))
+                return true;
+            current = current.split('/').slice(0, -1).join('/') || '/';
+        }
+        return false;
+    }
+}
+export class ReadonlyDrive {
+    kind = 'drive';
+    name;
+    inner;
+    constructor(inner, name = `readonly:${inner.name || 'drive'}`) {
+        this.inner = inner;
+        this.name = name;
+    }
+    mount(ctx) {
+        return this.inner.mount?.({ ...ctx, mode: 'ro' });
+    }
+    unmount() {
+        return this.inner.unmount?.();
+    }
+    readText(path) {
+        return this.inner.readText(path);
+    }
+    exists(path) {
+        return this.inner.exists(path);
+    }
+    readdir(path) {
+        return this.inner.readdir(path);
+    }
+    stat(path) {
+        if (!this.inner.stat)
+            return this.inner.exists(path).then((exists) => {
+                if (!exists)
+                    throw new Error(`file not found: ${normalizeKPath(path)}`);
+                return { type: 'file' };
+            });
+        return this.inner.stat(path);
+    }
+    readLink(path) {
+        return this.inner.readLink ? this.inner.readLink(path) : Promise.resolve(undefined);
+    }
+    realPath(path) {
+        return this.inner.realPath?.(path);
+    }
+}
+export class MemoryDrive {
+    kind = 'drive';
+    name;
+    files = new Map();
+    symlinks = new Map();
+    modes = new Map();
+    mtimes = new Map();
+    constructor(tree = {}, { name = 'memory' } = {}) {
+        this.name = name;
+        this.loadTree('/', tree);
+    }
+    async readText(path) {
+        const kPath = this.resolveSymlinks(path, true);
+        const text = this.files.get(kPath);
+        if (text === undefined)
+            throw new Error(`file not found: ${kPath}`);
+        return text;
+    }
+    async writeText(path, text) {
+        const kPath = this.resolveSymlinks(path, true);
+        this.files.set(kPath, text);
+        if (!this.modes.has(kPath))
+            this.modes.set(kPath, 0o644);
+        this.mtimes.set(kPath, new Date().toISOString());
+    }
+    async rm(path, options = {}) {
+        const kPath = this.resolveSymlinks(path, false);
+        if (this.symlinks.delete(kPath)) {
+            this.modes.delete(kPath);
+            this.mtimes.delete(kPath);
+            return;
+        }
+        if (this.files.delete(kPath)) {
+            this.modes.delete(kPath);
+            this.mtimes.delete(kPath);
+            return;
+        }
+        const prefix = `${kPath.replace(/\/$/, '')}/`;
+        const matches = [...this.files.keys()].filter((file) => file.startsWith(prefix));
+        if (!matches.length) {
+            if (options.force)
+                return;
+            throw new Error(`file not found: ${kPath}`);
+        }
+        if (!options.recursive)
+            throw new Error(`directory not empty: ${kPath}`);
+        for (const file of matches) {
+            this.files.delete(file);
+            this.modes.delete(file);
+            this.mtimes.delete(file);
+        }
+    }
+    async rename(from, to) {
+        const source = this.resolveSymlinks(from, false);
+        const target = this.resolveSymlinks(to, false);
+        const link = this.symlinks.get(source);
+        if (link !== undefined) {
+            this.symlinks.delete(source);
+            this.symlinks.set(target, link);
+            this.moveMode(source, target);
+            this.moveMtime(source, target);
+            return;
+        }
+        if (this.files.has(source)) {
+            const value = this.files.get(source) ?? '';
+            this.files.delete(source);
+            this.files.set(target, value);
+            this.moveMode(source, target);
+            this.moveMtime(source, target);
+            return;
+        }
+        const sourcePrefix = `${source.replace(/\/$/, '')}/`;
+        const targetPrefix = `${target.replace(/\/$/, '')}/`;
+        const matches = [...this.files.entries()].filter(([file]) => file.startsWith(sourcePrefix));
+        if (!matches.length)
+            throw new Error(`file not found: ${source}`);
+        for (const [file, value] of matches) {
+            this.files.delete(file);
+            this.files.set(`${targetPrefix}${file.slice(sourcePrefix.length)}`, value);
+            this.moveMode(file, `${targetPrefix}${file.slice(sourcePrefix.length)}`);
+            this.moveMtime(file, `${targetPrefix}${file.slice(sourcePrefix.length)}`);
+        }
+    }
+    async exists(path) {
+        const noFollow = this.resolveSymlinks(path, false);
+        if (this.symlinks.has(noFollow))
+            return true;
+        const kPath = this.resolveSymlinks(path, true);
+        if (this.files.has(kPath))
+            return true;
+        const prefix = `${kPath.replace(/\/$/, '')}/`;
+        return [...this.files.keys()].some((file) => file.startsWith(prefix));
+    }
+    async readdir(path) {
+        const kPath = this.resolveSymlinks(path, true);
+        const prefix = kPath === '/' ? '/' : `${kPath.replace(/\/$/, '')}/`;
+        const names = new Map();
+        for (const file of this.files.keys()) {
+            if (!file.startsWith(prefix))
+                continue;
+            const rest = file.slice(prefix.length);
+            if (!rest)
+                continue;
+            const [name, ...tail] = rest.split('/');
+            if (!name)
+                continue;
+            names.set(name, tail.length ? 'dir' : 'file');
+        }
+        for (const linkPath of this.symlinks.keys()) {
+            if (linkPath.startsWith(prefix)) {
+                const rest = linkPath.slice(prefix.length);
+                const [name, ...tail] = rest.split('/');
+                if (name)
+                    names.set(name, tail.length ? 'dir' : 'symlink');
+            }
+        }
+        return [...names.entries()].map(([name, type]) => ({ name, type }));
+    }
+    async stat(path) {
+        const noFollow = this.resolveSymlinks(path, false);
+        const link = this.symlinks.get(noFollow);
+        if (link !== undefined)
+            return { type: 'symlink', size: new TextEncoder().encode(link).byteLength, mode: this.modes.get(noFollow) ?? 0o777, mtime: this.mtimes.get(noFollow) };
+        const kPath = this.resolveSymlinks(path, true);
+        if (this.files.has(kPath))
+            return { type: 'file', size: this.files.get(kPath)?.length ?? 0, mode: this.modes.get(kPath) ?? 0o644, mtime: this.mtimes.get(kPath) };
+        if (await this.exists(kPath))
+            return { type: 'dir', mode: this.modes.get(kPath) ?? 0o755, mtime: this.mtimes.get(kPath) };
+        throw new Error(`file not found: ${kPath}`);
+    }
+    async chmod(path, mode) {
+        const noFollow = this.resolveSymlinks(path, false);
+        const kPath = this.symlinks.has(noFollow) ? this.resolveSymlinks(path, true) : noFollow;
+        if (!await this.exists(kPath))
+            throw new Error(`file not found: ${kPath}`);
+        this.modes.set(kPath, mode & 0o777);
+    }
+    async utime(path, mtime) {
+        const noFollow = this.resolveSymlinks(path, false);
+        const kPath = this.symlinks.has(noFollow) ? this.resolveSymlinks(path, true) : noFollow;
+        if (!await this.exists(kPath))
+            throw new Error(`file not found: ${kPath}`);
+        this.mtimes.set(kPath, mtime);
+    }
+    async symlink(target, path) {
+        const linkPath = this.resolveSymlinks(path, false);
+        if (await this.exists(linkPath))
+            throw new Error(`file exists: ${linkPath}`);
+        this.symlinks.set(linkPath, target);
+        this.modes.set(linkPath, 0o777);
+        this.mtimes.set(linkPath, new Date().toISOString());
+    }
+    async readLink(path) {
+        return this.symlinks.get(this.resolveSymlinks(path, false));
+    }
+    loadTree(basePath, tree) {
+        for (const [name, value] of Object.entries(tree)) {
+            const child = normalizeKPath(joinPath(basePath, name));
+            if (typeof value === 'string') {
+                this.files.set(child, value);
+                this.modes.set(child, 0o644);
+                this.mtimes.set(child, new Date().toISOString());
+            }
+            else if (value instanceof Uint8Array) {
+                this.files.set(child, new TextDecoder().decode(value));
+                this.modes.set(child, 0o644);
+                this.mtimes.set(child, new Date().toISOString());
+            }
+            else if (value && typeof value === 'object' && !Array.isArray(value)) {
+                this.modes.set(child, 0o755);
+                this.mtimes.set(child, new Date().toISOString());
+                this.loadTree(child, value);
+            }
+            else {
+                this.files.set(child, JSON.stringify(value, null, 2));
+                this.modes.set(child, 0o644);
+                this.mtimes.set(child, new Date().toISOString());
+            }
+        }
+    }
+    moveMode(from, to) {
+        const mode = this.modes.get(from);
+        this.modes.delete(from);
+        if (mode !== undefined)
+            this.modes.set(to, mode);
+    }
+    moveMtime(from, to) {
+        const mtime = this.mtimes.get(from);
+        this.mtimes.delete(from);
+        if (mtime !== undefined)
+            this.mtimes.set(to, mtime);
+    }
+    resolveSymlinks(path, followFinal) {
+        let currentPath = normalizeKPath(path);
+        for (let depth = 0; depth < 40; depth += 1) {
+            const parts = currentPath.split('/').filter(Boolean);
+            if (!parts.length)
+                return '/';
+            let current = '/';
+            let changed = false;
+            for (let index = 0; index < parts.length; index += 1) {
+                current = joinPath(current, parts[index]);
+                const isFinal = index === parts.length - 1;
+                if (isFinal && !followFinal)
+                    break;
+                const target = this.symlinks.get(current);
+                if (target === undefined)
+                    continue;
+                const base = target.startsWith('/') ? target : joinPath(current.split('/').slice(0, -1).join('/') || '/', target);
+                const rest = parts.slice(index + 1).join('/');
+                currentPath = normalizeKPath(rest ? joinPath(base, rest) : base);
+                changed = true;
+                break;
+            }
+            if (!changed)
+                return currentPath;
+        }
+        throw new Error(`too many symbolic link levels: ${path}`);
+    }
+}
+export function memoryDrive(tree = {}, options = {}) {
+    const drive = new MemoryDrive(tree, { name: options.name });
+    return options.readonly ? new ReadonlyDrive(drive, options.name ? `${options.name}:readonly` : undefined) : drive;
+}
+export function overlayMountTable(kstate, sessionId, base) {
+    const overlayRoot = `/var/k/overlays/${encodeURIComponent(sessionId)}`;
+    const rootEntry = base.resolve('/');
+    const table = new MountTable(new OverlayDrive({
+        name: `overlay:${sessionId}:/`,
+        lower: rootEntry.drive,
+        upper: new KStateDrive(kstate, { name: `upper:${sessionId}:/`, prefix: `${overlayRoot}/root` }),
+    }));
+    for (const { path, drive, mode } of base.list()) {
+        if (path === '/')
+            continue;
+        if (drive instanceof KStateDrive) {
+            table.mount(path, new OverlayDrive({
+                name: `overlay:${sessionId}:${path}`,
+                lower: drive,
+                upper: new KStateDrive(kstate, { name: `upper:${sessionId}:${path}`, prefix: `${overlayRoot}/mounts/${encodeURIComponent(path)}` }),
+            }), { mode });
+        }
+        else {
+            table.mount(path, drive, { mode: 'ro' });
+        }
+    }
+    return table;
+}
+export function isMountBinding(value) {
+    return Boolean(value && typeof value === 'object'
+        && value.kind === 'mount-binding'
+        && (value.mode === 'ro' || value.mode === 'rw')
+        && 'source' in value);
+}
+export function isDrive(value) {
+    return Boolean(value && typeof value === 'object'
+        && value.kind === 'drive'
+        && typeof value.readText === 'function'
+        && typeof value.exists === 'function'
+        && typeof value.readdir === 'function');
+}
+function resolveRelativeDrivePath(path, target) {
+    if (target.startsWith('/'))
+        return normalizeKPath(target);
+    const base = path.split('/').slice(0, -1).join('/') || '/';
+    return normalizeKPath(joinPath(base, target));
+}
+export async function materializeFileTree(kstate, mountPath, source) {
+    if (typeof source === 'string') {
+        await kstate.writeText(mountPath, source);
+        return;
+    }
+    if (source instanceof Uint8Array) {
+        await kstate.writeText(mountPath, new TextDecoder().decode(source));
+        return;
+    }
+    if (source && typeof source === 'object' && !Array.isArray(source)) {
+        await kstate.ensureRootDir(mountPath);
+        for (const [name, value] of Object.entries(source)) {
+            await materializeFileTree(kstate, joinPath(mountPath, name), value);
+        }
+        return;
+    }
+    await kstate.writeText(mountPath, JSON.stringify(source, null, 2));
+}
+//# sourceMappingURL=drive.js.map