@kruntime/komputer 0.1.0

package/dist/komputer.js

@@ -0,0 +1,733 @@
+import { AgentSession } from "./agent-session.js";
+import { defaultDisk, KState, normalizeKPath } from "./kstate.js";
+import { echoModel, modelset } from "./model.js";
+import { id, now } from "./utils.js";
+import { isDrive, isMountBinding, KStateDrive, materializeFileTree, MountTable, readMountRegistry, recordMount } from "./drive.js";
+import { appendCronRun, summarizeCronResult } from "./cron.js";
+import { noShellRemote } from "./remote.js";
+export class Komputer {
+    image;
+    kstate;
+    models;
+    remotes;
+    defaultRemoteName;
+    mounts;
+    commands;
+    hooks;
+    crons;
+    secrets;
+    networkHosts;
+    sessions;
+    restoredMountPaths;
+    closed;
+    workerId;
+    leaseTtlMs;
+    leaseHeartbeat;
+    constructor({ image, kstate, models, remotes, defaultRemoteName }) {
+        this.image = normalizeImage(image);
+        this.kstate = kstate;
+        this.models = models;
+        this.remotes = remotes;
+        this.defaultRemoteName = defaultRemoteName;
+        this.mounts = new MountTable(new KStateDrive(this.kstate, { name: 'kstate', prefix: '/' }));
+        this.commands = new Map(Object.entries(this.image.commands || {}));
+        this.hooks = [...(this.image.hooks || [])];
+        this.crons = [...(this.image.crons || [])];
+        this.secrets = new Map();
+        this.networkHosts = new Map();
+        this.sessions = new Map();
+        this.restoredMountPaths = new Set();
+        this.closed = false;
+        this.workerId = id('worker');
+        this.leaseTtlMs = 30_000;
+        this.leaseHeartbeat = true;
+    }
+    static async boot(image = {}, options = {}) {
+        const normalized = normalizeImage(image);
+        const disk = await resolveDisk(options);
+        const kstate = new KState(disk);
+        await kstate.init({ imageDigest: normalized.digest });
+        const models = modelset({ default: echoModel('default'), ...(normalized.models || {}), ...(options.models || {}) });
+        const { remotes, defaultRemoteName } = normalizeRemotes(options.remotes);
+        const computer = new Komputer({ image: normalized, kstate, models, remotes, defaultRemoteName });
+        computer.leaseTtlMs = options.leaseTtlMs ?? computer.leaseTtlMs;
+        computer.leaseHeartbeat = options.leaseHeartbeat ?? computer.leaseHeartbeat;
+        await computer.restoreMountRegistry();
+        await computer.mounts.activate();
+        for (const [name, value] of Object.entries(options.secrets || {})) {
+            if (typeof value === 'string')
+                computer.secret(name, value);
+        }
+        for (const [name, value] of Object.entries(options.hosts || {}))
+            computer.host(name, value);
+        await computer.installImage();
+        await computer.writeRuntimeMeta(options);
+        return computer;
+    }
+    async installImage() {
+        for (const [agentName, agentDefinition] of Object.entries(this.image.agents)) {
+            const agent = agentDefinition;
+            const home = agent.home || `/home/${agentName}`;
+            await this.kstate.ensureRootDir(home);
+            await this.kstate.ensureRootDir(`${home}/work`);
+            await this.kstate.ensureRootDir(`${home}/memory`);
+            await this.kstate.ensureRootDir(`${home}/.k`);
+        }
+        for (const [path, content] of Object.entries(this.image.files || {})) {
+            if (!(await this.kstate.exists(path))) {
+                await this.kstate.writeText(path, typeof content === 'string' ? content : JSON.stringify(content, null, 2));
+            }
+        }
+        await this.kstate.ensureRootDir('/etc/k');
+        await this.kstate.ensureRootDir('/etc');
+        await this.kstate.ensureRootDir('/sys');
+        await this.writeSysFiles();
+    }
+    async writeRuntimeMeta(options = {}) {
+        const meta = {
+            schema: 'k.runtime.v1',
+            bootId: id('boot'),
+            bootedAt: now(),
+            workerId: this.workerId,
+            imageDigest: this.image.digest,
+            agents: Object.keys(this.image.agents),
+            models: this.models.aliases(),
+            remotes: [...this.remotes.keys()],
+            defaultRemote: this.defaultRemoteName,
+            hosts: Object.keys(options.hosts || {}),
+        };
+        await this.kstate.writeJson('/meta/runtime.json', meta);
+    }
+    async writeSysFiles() {
+        await this.kstate.writeText('/sys/models.md', `# Models\n\n${this.models.aliases().map((name) => `- ${name}`).join('\n')}\n`);
+        const registry = await readMountRegistry(this.kstate);
+        const mounts = this.mounts.list()
+            .map(({ path, drive, mode }) => `- ${path}: ${drive.name || 'drive'}${mode === 'ro' ? ' (ro)' : ''}`)
+            .concat(registry
+            .filter((entry) => entry.kind === 'external' && !this.mounts.has(entry.path))
+            .map((entry) => `- ${entry.path}: ${entry.driveName} (external, ${entry.mode}, not bound)`))
+            .join('\n');
+        await this.kstate.writeText('/sys/mounts.md', `# Mounts\n\n${mounts}\n`);
+        await this.kstate.writeText('/sys/session.md', '# Session\n\nSession information is written under /var/k/sessions.\n');
+        await this.kstate.writeText('/sys/secrets.md', `# Secrets\n\n${[...this.secrets.keys()].sort().map((name) => `- ${name}`).join('\n')}\n`);
+        await this.kstate.writeText('/sys/hosts.md', `# Hosts\n\n${[...this.networkHosts.keys()].sort().map((name) => `- ${name}`).join('\n')}\n`);
+        await this.kstate.writeText('/etc/hosts', [
+            '127.0.0.1 localhost',
+            ...[...this.networkHosts.keys()].sort().map((name, index) => `10.0.0.${index + 2} ${name}`),
+            '',
+        ].join('\n'));
+        await this.kstate.writeText('/etc/hostname', 'komputer\n');
+    }
+    async mount(path, sourceOrBinding, options = {}) {
+        const mountPath = normalizeKPath(path);
+        const binding = normalizeMountBinding(sourceOrBinding, options);
+        const { source, mode } = binding;
+        if (this.mounts.has(mountPath)) {
+            if (!this.restoredMountPaths.has(mountPath))
+                throw new Error(`drive already mounted at ${mountPath}`);
+            await this.mounts.unmount(mountPath);
+            this.restoredMountPaths.delete(mountPath);
+        }
+        if (isDrive(source)) {
+            this.mounts.mount(mountPath, source, { mode });
+            try {
+                await this.mounts.activate();
+                await recordMount(this.kstate, {
+                    path: mountPath,
+                    kind: 'external',
+                    driveName: source.name || 'drive',
+                    mode,
+                    recoverable: false,
+                    at: now(),
+                });
+                await this.writeSysFiles();
+            }
+            catch (error) {
+                await this.mounts.unmount(mountPath).catch(() => undefined);
+                throw error;
+            }
+            return;
+        }
+        await materializeFileTree(this.kstate, mountPath, source);
+        const drive = new KStateDrive(this.kstate, { name: `owned:${mountPath}`, prefix: mountPath });
+        this.mounts.mount(mountPath, drive, { mode });
+        try {
+            await this.mounts.activate();
+            await recordMount(this.kstate, {
+                path: mountPath,
+                kind: 'owned',
+                driveName: drive.name,
+                mode,
+                recoverable: true,
+                prefix: mountPath,
+                at: now(),
+            });
+            await this.writeSysFiles();
+        }
+        catch (error) {
+            await this.mounts.unmount(mountPath).catch(() => undefined);
+            throw error;
+        }
+    }
+    async restoreMountRegistry() {
+        const registry = await readMountRegistry(this.kstate);
+        for (const entry of registry) {
+            if (entry.path === '/' || this.mounts.has(entry.path))
+                continue;
+            if (entry.kind !== 'owned' || !entry.recoverable)
+                continue;
+            this.mounts.mount(entry.path, new KStateDrive(this.kstate, {
+                name: entry.driveName || `owned:${entry.path}`,
+                prefix: entry.prefix || entry.path,
+            }), { mode: entry.mode });
+            this.restoredMountPaths.add(entry.path);
+        }
+    }
+    realPath(path) {
+        return this.realPathInfo(path)?.realPath;
+    }
+    realPathInfo(path) {
+        const resolved = this.mounts.resolve(path);
+        const realPath = resolved.drive.realPath?.(resolved.drivePath);
+        return realPath ? { realPath, mode: resolved.mode } : undefined;
+    }
+    secret(name, value) {
+        this.secrets.set(name, value);
+        return this;
+    }
+    remote(name, value) {
+        this.remotes.set(name, value);
+        return this;
+    }
+    defaultRemote() {
+        const remote = this.remotes.get(this.defaultRemoteName);
+        if (!remote)
+            throw new Error(`default remote not bound: ${this.defaultRemoteName}`);
+        return remote;
+    }
+    getRemote(name = this.defaultRemoteName) {
+        const remote = this.remotes.get(name);
+        if (!remote)
+            throw new Error(`remote not bound: ${name}`);
+        return remote;
+    }
+    host(name, value) {
+        this.networkHosts.set(name, value);
+        return this;
+    }
+    readSecret(name) {
+        const value = this.secrets.get(name);
+        if (value === undefined)
+            throw new Error(`secret not bound: ${name}`);
+        return value;
+    }
+    async fetchNetwork(url, init = {}) {
+        const parsed = parseNetworkUrl(url);
+        const request = {
+            url: parsed.url,
+            host: parsed.host,
+            path: parsed.path,
+            method: init.method || 'GET',
+            headers: init.headers || {},
+            body: init.body,
+        };
+        const local = this.networkHosts.get(parsed.host);
+        if (local)
+            return resolveNetworkHost(local, request);
+        if (!this.defaultRemote().capabilities.network || typeof fetch !== 'function') {
+            throw new Error(`network host not bound and remote fetch is unavailable: ${parsed.host}`);
+        }
+        const response = await fetch(parsed.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+        });
+        return {
+            status: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: await response.text(),
+        };
+    }
+    async login(agentName = 'assistant', options = {}) {
+        if (this.closed)
+            throw new Error('Komputer is closed');
+        if (!this.image.agents[agentName])
+            throw new Error(`agent not declared in image: ${agentName}`);
+        const sessionId = options.id || `${agentName}:default`;
+        const key = `${agentName}\0${sessionId}`;
+        const cached = this.sessions.get(key);
+        if (cached && !cached.closed)
+            return cached;
+        if (cached?.closed)
+            this.sessions.delete(key);
+        const requestedMode = options.mode || 'normal';
+        const scopedMode = options.scope
+            ? { name: typeof requestedMode === 'string' ? requestedMode : requestedMode.name, scope: options.scope }
+            : requestedMode;
+        const session = new AgentSession({
+            computer: this,
+            agentName,
+            sessionId,
+            mode: scopedMode,
+        });
+        let initialized = false;
+        try {
+            await session.init();
+            initialized = true;
+            this.installHooks(session);
+            await this.runLogin(session);
+            this.sessions.set(key, session);
+            await session.trace('session.login', {
+                agent: agentName,
+                sessionId,
+                mode: session.mode,
+                by: options.by || 'program:login',
+            });
+            return session;
+        }
+        catch (error) {
+            if (session.lease) {
+                if (initialized)
+                    await session.detach().catch(() => undefined);
+                else
+                    await session.abandonStartup().catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+    async runLogin(agent) {
+        const login = this.image.logins[agent.agentName];
+        if (!login)
+            return;
+        await login(agent, agent.initResult ?? { firstLogin: false, recovered: true });
+        await agent.ready();
+    }
+    async recoverSessions(options = {}) {
+        const skipBusy = options.skipBusy ?? true;
+        const recovered = [];
+        for (const sessionId of await this.kstate.listSessionIds()) {
+            const record = await this.kstate.readSession(sessionId);
+            if (!record?.agent || !this.image.agents[record.agent])
+                continue;
+            if (!options.includeClosed && record.status === 'closed')
+                continue;
+            try {
+                recovered.push(await this.login(record.agent, {
+                    id: sessionId,
+                    mode: record.mode || 'normal',
+                    scope: record.scope,
+                    by: 'system:recovery',
+                }));
+            }
+            catch (error) {
+                if (skipBusy && error instanceof Error && /lease busy/.test(error.message))
+                    continue;
+                throw error;
+            }
+        }
+        return recovered;
+    }
+    async detachIdleSessions(options = {}) {
+        const idleForMs = Math.max(0, options.idleForMs ?? 0);
+        const nowMs = timeMs(options.now ?? Date.now());
+        const detached = [];
+        for (const [key, session] of [...this.sessions.entries()]) {
+            if (session.closed) {
+                this.sessions.delete(key);
+                continue;
+            }
+            const record = await this.kstate.readSession(session.sessionId);
+            const activity = timeMs(record?.updatedAt ?? record?.createdAt ?? 0);
+            if (nowMs - activity < idleForMs)
+                continue;
+            if (!options.includeActiveJobs) {
+                const jobs = await session.jobs();
+                if (jobs.some((job) => job.status === 'running'))
+                    continue;
+            }
+            await session.detach();
+            this.sessions.delete(key);
+            detached.push(session.sessionId);
+        }
+        return detached;
+    }
+    defineCommand(name, definition) {
+        const command = typeof definition === 'function'
+            ? { name, kind: 'module', handler: definition }
+            : { name, ...definition, kind: definition.kind ?? 'module' };
+        this.commands.set(name, command);
+        return command;
+    }
+    bridgeCommand(name, definition) {
+        const command = makeBridgeCommand({ name, ...definition, remote: definition.remote || this.defaultRemoteName });
+        this.commands.set(name, command);
+        return command;
+    }
+    async runCron(name, options = {}) {
+        const matched = this.crons.filter((cron) => !name || cron.name === name);
+        if (!matched.length)
+            throw new Error(`cron not found: ${name}`);
+        const results = [];
+        for (const cron of matched) {
+            const agentName = options.agent || cron.user || cron.agent || this.defaultAgentName();
+            if (cron.scope === 'system' && !cron.user && !options.agent) {
+                throw new Error(`system cron must declare user: ${cron.path || cron.name}`);
+            }
+            const lease = await this.kstate.acquireRuntimeLease('crons', cron.name, { owner: this.workerId, ttlMs: this.leaseTtlMs });
+            const runId = id('cron');
+            const startedAt = now();
+            const sessionId = options.sessionId || `cron:${cron.name}`;
+            let agent;
+            try {
+                agent = await this.login(agentName, { id: sessionId });
+                const ctx = this.runtimeContext(agent, { kind: 'cron', name: cron.name });
+                await appendCronRun(this.kstate, {
+                    runId,
+                    name: cron.name,
+                    agent: agentName,
+                    sessionId,
+                    workerId: this.workerId,
+                    kind: cron.kind,
+                    path: cron.path,
+                    status: 'running',
+                    startedAt,
+                });
+                await agent.signal('cron.start', { runId, name: cron.name, kind: cron.kind, path: cron.path });
+                let result;
+                if (cron.kind === 'module') {
+                    if (!cron.handler)
+                        throw new Error(`cron has no handler: ${cron.name}`);
+                    result = await cron.handler(ctx, options.input || {});
+                }
+                else if (cron.kind === 'shell') {
+                    result = await agent.execInternal(String(cron.script ?? ''), { by: `system:cron:${cron.name}` });
+                }
+                else if (cron.kind === 'markdown') {
+                    result = await agent.run(String(cron.prompt ?? ''), { by: `system:cron:${cron.name}` });
+                }
+                const endedAt = now();
+                await appendCronRun(this.kstate, {
+                    runId,
+                    name: cron.name,
+                    agent: agentName,
+                    sessionId,
+                    workerId: this.workerId,
+                    status: 'completed',
+                    endedAt,
+                    result: summarizeCronResult(result),
+                });
+                await agent.signal('cron.end', { runId, name: cron.name, status: 'completed', result: summarizeCronResult(result) });
+                results.push(result);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const endedAt = now();
+                await appendCronRun(this.kstate, {
+                    runId,
+                    name: cron.name,
+                    agent: agentName,
+                    sessionId,
+                    workerId: this.workerId,
+                    status: 'failed',
+                    endedAt,
+                    error: message,
+                });
+                await agent?.signal('cron.end', { runId, name: cron.name, status: 'failed', error: message }, { level: 'error' });
+                throw error;
+            }
+            finally {
+                await lease.release();
+            }
+        }
+        return results;
+    }
+    installHooks(agent) {
+        for (const hook of this.hooks) {
+            if (!hook.event)
+                continue;
+            if (hook.scope === 'agent' && hook.agent && hook.agent !== agent.agentName)
+                continue;
+            agent.hook(hook.event, async (ctx) => {
+                if (hook.kind === 'module')
+                    return hook.handler?.(ctx);
+                if (hook.kind === 'shell') {
+                    await agent.execInternal(String(hook.script ?? ''), { by: `system:hook:${hook.event}` });
+                    return undefined;
+                }
+                if (hook.kind === 'markdown') {
+                    await agent.run(String(hook.prompt ?? ''), { by: `system:hook:${hook.event}` });
+                    return undefined;
+                }
+                return undefined;
+            });
+        }
+    }
+    runtimeContext(agent, meta = {}) {
+        const args = recordField(meta.input) || recordField(meta.args) || {};
+        return {
+            ...meta,
+            input: args,
+            args,
+            computer: agent.localComputer,
+            agent,
+            exec: (command, options = {}) => agent.execCommand(command, options),
+            remote: (name) => ({
+                name,
+                exec: (command, options = {}) => typeof command === 'string'
+                    ? agent.execCommand(command, { ...options, remote: options.remote || name })
+                    : agent.execCommand({ ...command, remote: command.remote || name }, { ...options, remote: options.remote || name }),
+            }),
+            model: (alias = 'default') => {
+                const model = this.models.get(alias);
+                return {
+                    generate: (req = {}) => model.complete({
+                        messages: [{ role: 'user', content: [{ type: 'text', text: req.input || req.text || req.prompt || '' }] }],
+                    }),
+                    ask: (input) => model.complete({
+                        messages: [{ role: 'user', content: [{ type: 'text', text: String(input) }] }],
+                    }),
+                };
+            },
+            stdout: (text) => ({ type: 'stdout', text: String(text) }),
+            stderr: (text, code = 1) => ({ type: 'stderr', text: String(text), code }),
+            result: (output) => ({
+                stdout: String(output.stdout ?? ''),
+                stderr: String(output.stderr ?? ''),
+                code: output.code ?? (output.stderr ? 1 : 0),
+            }),
+            json: (value) => ({ type: 'json', value }),
+            secret: (name) => this.readSecret(name),
+            emit: (name, data, options) => agent.signal(name, data, options),
+        };
+    }
+    defaultAgentName() {
+        return Object.keys(this.image.agents)[0] || 'assistant';
+    }
+    async snapshot({ label } = {}) {
+        const sessions = [];
+        for (const sessionId of await this.kstate.listSessionIds()) {
+            const session = await this.kstate.readSession(sessionId);
+            const trace = await this.kstate.readSessionJsonl(sessionId, 'trace.jsonl');
+            const messages = await this.kstate.readSessionJsonl(sessionId, 'messages.full.jsonl');
+            const events = await this.kstate.readSessionJsonl(sessionId, 'events.jsonl');
+            const inputs = await this.kstate.readSessionJsonl(sessionId, 'inputs.jsonl');
+            const processes = await this.kstate.readSessionJsonl(sessionId, 'processes/processes.jsonl');
+            sessions.push({
+                id: sessionId,
+                agent: session?.agent,
+                status: session?.status,
+                mode: session?.mode,
+                worker: session?.worker,
+                traceSeq: numberField(trace.at(-1), 'traceSeq', -1),
+                messageSeq: numberField(messages.at(-1), 'seq', -1),
+                eventCursor: numberField(events.at(-1), 'cursor', -1),
+                inputCount: inputs.length,
+                processCount: processes.length,
+            });
+        }
+        const snapshot = {
+            schema: 'k.snapshot.v1',
+            id: id('snapshot'),
+            label,
+            createdAt: now(),
+            imageDigest: this.image.digest,
+            disk: {
+                kind: this.kstate.backend.kind,
+                name: this.kstate.path,
+            },
+            sessions,
+            kstate: this.kstate.path,
+        };
+        await this.kstate.writeJson(`/snapshots/${snapshot.id}.json`, snapshot);
+        return snapshot;
+    }
+    stats() {
+        let localActiveProcesses = 0;
+        for (const session of this.sessions.values()) {
+            localActiveProcesses += session.stats().localActiveProcesses;
+        }
+        return {
+            closed: this.closed,
+            workerId: this.workerId,
+            imageDigest: this.image.digest,
+            remote: this.defaultRemoteName,
+            remotes: [...this.remotes.keys()],
+            localSessions: this.sessions.size,
+            localActiveProcesses,
+            commands: this.commands.size,
+            hooks: this.hooks.length,
+            crons: this.crons.length,
+            mounts: this.mounts.list().length,
+            hosts: this.networkHosts.size,
+            models: this.models.aliases().length,
+        };
+    }
+    async close(options = {}) {
+        if (this.closed)
+            return;
+        const action = options.endSessions ? 'close' : 'detach';
+        let closeError;
+        try {
+            await Promise.all([...this.sessions.values()].map((session) => session[action]()));
+        }
+        catch (error) {
+            closeError = error;
+        }
+        finally {
+            try {
+                await this.mounts.unmountAll();
+            }
+            catch (error) {
+                closeError ??= error;
+            }
+            try {
+                await Promise.all([...new Set(this.remotes.values())].map((remote) => remote.close?.()));
+            }
+            catch (error) {
+                closeError ??= error;
+            }
+            try {
+                await this.kstate.backend.close?.();
+            }
+            catch (error) {
+                closeError ??= error;
+            }
+            this.closed = true;
+            this.sessions.clear();
+        }
+        if (closeError)
+            throw closeError;
+    }
+}
+function normalizeRemotes(remotes) {
+    const entries = Object.entries(remotes || {});
+    if (!entries.length)
+        return { remotes: new Map([['local', noShellRemote]]), defaultRemoteName: 'local' };
+    const table = new Map(entries);
+    const defaultRemoteName = table.has('local') ? 'local' : entries[0][0];
+    return { remotes: table, defaultRemoteName };
+}
+async function resolveDisk(options) {
+    if (options.disk)
+        return options.disk;
+    return defaultDisk();
+}
+export function image(definition = {}) {
+    return normalizeImage(definition);
+}
+export function agent(definition = {}) {
+    return definition;
+}
+export async function boot(imageDefinition = {}, options = {}) {
+    return Komputer.boot(imageDefinition, options);
+}
+function normalizeImage(image) {
+    const agents = image.agents && Object.keys(image.agents).length
+        ? image.agents
+        : { assistant: { home: '/home/assistant', model: 'default' } };
+    return {
+        schema: 'k.image.v1',
+        digest: image.digest || 'dev-image',
+        agents,
+        files: image.files || {},
+        models: image.models || {},
+        logins: image.logins || {},
+        needs: image.needs || {},
+        commands: image.commands || {},
+        hooks: image.hooks || [],
+        crons: image.crons || [],
+        sourceDir: image.sourceDir,
+    };
+}
+function makeBridgeCommand(definition) {
+    return {
+        ...definition,
+        kind: 'module',
+        async handler(ctx, input = {}) {
+            const argv = typeof definition.argv === 'function'
+                ? definition.argv(input)
+                : definition.argv ?? inputArgv(input);
+            return ctx.exec({
+                command: definition.command,
+                argv,
+                stdin: typeof input.stdin === 'string' ? input.stdin : undefined,
+                remote: definition.remote,
+                limits: definition.limits,
+            }, {
+                by: typeof input.by === 'string' ? input.by : 'system:bridge-command',
+            });
+        },
+    };
+}
+function inputArgv(input) {
+    const argv = input.argv;
+    if (!Array.isArray(argv))
+        return [];
+    return argv.filter((value) => typeof value === 'string');
+}
+function normalizeMountBinding(sourceOrBinding, options) {
+    if (isMountBinding(sourceOrBinding))
+        return sourceOrBinding;
+    return { source: sourceOrBinding, mode: options.mode ?? 'rw' };
+}
+function numberField(value, key, fallback) {
+    return value && typeof value === 'object' && typeof value[key] === 'number'
+        ? value[key]
+        : fallback;
+}
+function timeMs(value) {
+    if (value instanceof Date)
+        return value.getTime();
+    if (typeof value === 'number')
+        return value;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function recordField(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function parseNetworkUrl(input) {
+    const raw = input.includes('://') ? input : `http://${input}`;
+    const parsed = new URL(raw);
+    return {
+        url: parsed.toString(),
+        host: parsed.hostname,
+        path: `${parsed.pathname}${parsed.search}`,
+    };
+}
+async function resolveNetworkHost(host, request) {
+    if (typeof host === 'function')
+        return host(request);
+    if (typeof host === 'string')
+        return fetchRealUrl(joinBaseUrl(host, request.path), request);
+    if ('fetch' in host && typeof host.fetch === 'function')
+        return host.fetch(request);
+    if ('url' in host && typeof host.url === 'string')
+        return fetchRealUrl(joinBaseUrl(host.url, request.path), request);
+    const files = (('files' in host && host.files && typeof host.files === 'object') ? host.files : host);
+    const key = request.path.split('?')[0] || '/';
+    const body = files[key] ?? files[key.replace(/^\//, '')];
+    if (body === undefined)
+        return { status: 404, body: `not found: ${key}\n` };
+    return { status: 200, body };
+}
+async function fetchRealUrl(url, request) {
+    if (typeof fetch !== 'function')
+        throw new Error('global fetch is not available for network host');
+    const response = await fetch(url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+    });
+    return {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: await response.text(),
+    };
+}
+function joinBaseUrl(base, path) {
+    const cleanBase = base.replace(/\/+$/, '');
+    const cleanPath = path.startsWith('/') ? path : `/${path}`;
+    return `${cleanBase}${cleanPath}`;
+}
+//# sourceMappingURL=komputer.js.map