@platless/axom-cli 0.3.13 → 0.5.9

package/dist/workstation/acp/sessionScope.js

@@ -1,19 +0,0 @@
-import { SessionMapperState } from './sessionUpdateMapper.js';
-export function scopeKey(scope) {
-    return JSON.stringify([scope.rootRuntimeId, scope.nativeSessionId]);
-}
-export class SessionMapperScopes {
-    create;
-    states = new Map();
-    constructor(create = () => new SessionMapperState()) {
-        this.create = create;
-    }
-    get(scope) {
-        const key = scopeKey(scope);
-        let state = this.states.get(key);
-        if (!state)
-            this.states.set(key, state = this.create(scope));
-        return state;
-    }
-    clear() { this.states.clear(); }
-}

package/dist/workstation/filePaths.js

@@ -1,174 +0,0 @@
-import { lstat, realpath } from 'node:fs/promises';
-import { isAbsolute, join } from 'node:path';
-export class ComputerFileError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'ComputerFileError';
-    }
-}
-export function computerFileError(error) {
-    if (error instanceof ComputerFileError)
-        return error;
-    const code = error?.code;
-    if (code === 'ENOENT')
-        return new ComputerFileError('not_found', 'File or parent directory not found');
-    if (code === 'EACCES' || code === 'EPERM')
-        return new ComputerFileError('permission_denied', 'File access denied');
-    if (code === 'EEXIST')
-        return new ComputerFileError('conflict', 'Target already exists');
-    if (code === 'ELOOP')
-        return new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-    return new ComputerFileError('io_error', 'File operation failed');
-}
-/** Validate portable slash components before touching the filesystem. */
-export function validateComputerFilePath(path) {
-    if (!path || path.includes('\\') || path.includes(':') || path.includes('\0') || isAbsolute(path)) {
-        throw new ComputerFileError('invalid_path', 'Path must be relative to the selected workspace');
-    }
-    const components = path.split('/');
-    if (components.some(component => !component || component === '.' || component === '..')) {
-        throw new ComputerFileError('invalid_path', 'Path contains an unsafe component');
-    }
-    return components;
-}
-/** The configured root may itself be a symlink; none of its descendants may be. */
-export async function resolveComputerFilePath(root, path, allowMissingLeaf) {
-    const components = validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    for (let index = 0; index < components.length; index++) {
-        cursor = join(cursor, components[index]);
-        let stat;
-        try {
-            stat = await lstat(cursor);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT' && allowMissingLeaf && index === components.length - 1)
-                return cursor;
-            throw computerFileError(error);
-        }
-        if (stat.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (index === components.length - 1) {
-            if (!stat.isFile())
-                throw new ComputerFileError('not_regular_file', 'Target is not a regular file');
-        }
-        else if (!stat.isDirectory()) {
-            throw new ComputerFileError('not_regular_file', 'Parent is not a directory');
-        }
-    }
-    return cursor;
-}
-/** Resolve only a leaf relative to an already pinned process cwd; never turn it back into an absolute pathname. */
-export async function resolvePinnedLeafPath(_root, path, allowMissingLeaf) {
-    const components = validateComputerFilePath(path);
-    if (components.length !== 1)
-        throw new ComputerFileError('invalid_path', 'Pinned file operation requires one path component');
-    try {
-        const entry = await lstat(path);
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isFile())
-            throw new ComputerFileError('not_regular_file', 'Target is not a regular file');
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT' || !allowMissingLeaf)
-            throw computerFileError(error);
-    }
-    return path;
-}
-/** Every component of a directory listing target must exist, be a directory, and not be a symlink; '' is the root. */
-export async function resolveComputerDirPath(root, path) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    for (const component of components) {
-        cursor = join(cursor, component);
-        let entry;
-        try {
-            entry = await lstat(cursor);
-        }
-        catch (error) {
-            throw computerFileError(error);
-        }
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isDirectory())
-            throw new ComputerFileError('not_regular_file', 'Target is not a directory');
-    }
-    return cursor;
-}
-/** Pinned variant for the file worker: '' lists the pinned cwd itself, otherwise exactly one component. */
-export async function resolvePinnedDirPath(_root, path) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    if (components.length > 1)
-        throw new ComputerFileError('invalid_path', 'Pinned directory operation requires at most one path component');
-    const target = path === '' ? '.' : join('.', path);
-    let entry;
-    try {
-        entry = await lstat(target);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    if (entry.isSymbolicLink())
-        throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-    if (!entry.isDirectory())
-        throw new ComputerFileError('not_regular_file', 'Target is not a directory');
-    return target;
-}
-/**
- * Locate the deepest existing ancestor for a directory creation. Without parents the anchor must be the
- * target's own parent (only the leaf may be missing); with parents any prefix may be missing. Existing
- * components must be directories and never symlinks; an existing leaf counts as "already created".
- */
-export async function resolveComputerDirCreatePath(root, path, parents) {
-    const components = validateComputerFilePath(path);
-    let cursor;
-    try {
-        cursor = await realpath(root);
-    }
-    catch (error) {
-        throw computerFileError(error);
-    }
-    let anchorIndex = 0;
-    for (; anchorIndex < components.length; anchorIndex++) {
-        const candidate = join(cursor, components[anchorIndex]);
-        let entry;
-        try {
-            entry = await lstat(candidate);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw computerFileError(error);
-            break;
-        }
-        if (entry.isSymbolicLink())
-            throw new ComputerFileError('invalid_path', 'Symbolic links are not allowed');
-        if (!entry.isDirectory())
-            throw new ComputerFileError('not_found', 'Path is not a directory');
-        cursor = candidate;
-    }
-    const missing = components.slice(anchorIndex);
-    if (!parents && missing.length > 1) {
-        throw new ComputerFileError('not_found', 'Parent directory not found');
-    }
-    return { anchor: cursor, missing };
-}
-/** Pinned variant for the file worker: create the missing components below the pinned cwd, one leaf at a time. */
-export async function resolvePinnedDirCreatePath(_root, path, _parents) {
-    const components = path === '' ? [] : validateComputerFilePath(path);
-    return { anchor: '.', missing: components };
-}

package/dist/workstation/fileWorker.js

@@ -1,81 +0,0 @@
-import { realpath } from 'node:fs/promises';
-import { isAbsolute, relative, sep } from 'node:path';
-import { computerFileError, ComputerFileError, resolvePinnedDirCreatePath, resolvePinnedDirPath, resolvePinnedLeafPath, } from './filePaths.js';
-import { createComputerDir, listComputerDir, readComputerFile, writeComputerFile, } from './fileOps.js';
-const controller = new AbortController();
-let started = false;
-let pending;
-/**
- * This worker is a separate process so its cwd is a kernel-pinned directory reference, not a
- * pathname re-resolved after validation. A swapped ancestor symlink may affect process launch,
- * but the post-launch realpath check then rejects it before touching the leaf. Directory
- * operations accept at most one pinned component: multi-component `parents` creation walks
- * one leaf at a time from the pinned anchor instead of re-resolving full pathnames.
- */
-process.on('message', (message) => {
-    if (message.kind === 'cancel') {
-        controller.abort();
-        if (pending) {
-            pending = undefined;
-            process.disconnect();
-        }
-        return;
-    }
-    if (message.kind === 'continue') {
-        const work = pending;
-        if (!work)
-            return;
-        pending = undefined;
-        void (async () => {
-            try {
-                if (work.kind === 'read') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await readComputerFile(request, controller.signal, resolvePinnedLeafPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else if (work.kind === 'write') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await writeComputerFile(request, controller.signal, resolvePinnedLeafPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else if (work.kind === 'ls') {
-                    const request = { ...work.request, root: '.' };
-                    const data = await listComputerDir(request, controller.signal, resolvePinnedDirPath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-                else {
-                    const request = { ...work.request, root: '.' };
-                    const data = await createComputerDir(request, controller.signal, resolvePinnedDirCreatePath);
-                    process.send?.({ ok: true, data }, () => process.disconnect());
-                }
-            }
-            catch (error) {
-                const mapped = computerFileError(error);
-                process.send?.({ ok: false, error: { code: mapped.code, message: mapped.message } }, () => process.disconnect());
-            }
-        })();
-        return;
-    }
-    if (started)
-        return;
-    started = true;
-    void (async () => {
-        try {
-            const parent = await realpath('.');
-            const rel = relative(message.root, parent);
-            if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-                throw new ComputerFileError('invalid_path', 'File parent escaped the configured workspace');
-            }
-            if (controller.signal.aborted) {
-                process.disconnect();
-                return;
-            }
-            pending = message;
-            process.send?.({ kind: 'ready' });
-        }
-        catch (error) {
-            const mapped = computerFileError(error);
-            process.send?.({ ok: false, error: { code: mapped.code, message: mapped.message } }, () => process.disconnect());
-        }
-    })();
-});

package/dist/workstation/fileWorkerClient.js

@@ -1,121 +0,0 @@
-import { fork } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { realpath } from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ComputerFileError, computerFileError, resolveComputerDirCreatePath, resolveComputerDirPath, resolveComputerFilePath } from './filePaths.js';
-const workerUrl = existsSync(new URL('./fileWorker.js', import.meta.url))
-    ? new URL('./fileWorker.js', import.meta.url)
-    : new URL('../../dist/workstation/fileWorker.js', import.meta.url);
-const writeLocks = new Map();
-async function serialWrite(target, action) {
-    const previous = writeLocks.get(target) ?? Promise.resolve();
-    let release;
-    const gate = new Promise(resolve => { release = resolve; });
-    const queued = previous.then(() => gate);
-    writeLocks.set(target, queued);
-    await previous;
-    try {
-        return await action();
-    }
-    finally {
-        release();
-        if (writeLocks.get(target) === queued)
-            writeLocks.delete(target);
-    }
-}
-async function execute(kind, request, anchor, leaf, signal, hooks) {
-    if (signal?.aborted)
-        throw new ComputerFileError('workstation_offline', 'File operation was cancelled');
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    await hooks?.afterValidation?.();
-    return new Promise((resolve, reject) => {
-        const child = fork(fileURLToPath(workerUrl), [], {
-            cwd: anchor, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], execArgv: [],
-        });
-        let settled = false;
-        let killTimer;
-        const finish = (error, data) => {
-            if (settled)
-                return;
-            settled = true;
-            signal?.removeEventListener('abort', abort);
-            if (error)
-                reject(error);
-            else
-                resolve(data);
-        };
-        const abort = () => {
-            if (settled)
-                return;
-            child.send({ kind: 'cancel' }, () => { });
-            killTimer = setTimeout(() => child.kill(), 2_000);
-            killTimer.unref();
-            finish(new ComputerFileError(kind === 'write' || kind === 'mkdir' ? 'outcome_unknown' : 'workstation_offline', 'File operation was cancelled'));
-        };
-        child.on('message', (message) => {
-            if (typeof message !== 'object' || message === null)
-                return;
-            const reply = message;
-            if (reply.kind === 'ready') {
-                void (async () => {
-                    try {
-                        await hooks?.afterWorkerReady?.();
-                        if (!settled)
-                            child.send({ kind: 'continue' }, error => { if (error)
-                                finish(computerFileError(error)); });
-                    }
-                    catch (error) {
-                        child.kill();
-                        finish(computerFileError(error));
-                    }
-                })();
-                return;
-            }
-            if (reply.ok === true)
-                finish(undefined, reply.data);
-            else if (reply.ok === false && reply.error)
-                finish(new ComputerFileError(reply.error.code, reply.error.message));
-        });
-        child.once('error', error => finish(computerFileError(error)));
-        child.once('exit', () => {
-            if (killTimer)
-                clearTimeout(killTimer);
-            finish(new ComputerFileError(kind === 'write' || kind === 'mkdir' ? 'outcome_unknown' : 'workstation_offline', 'File worker exited without a result'));
-        });
-        signal?.addEventListener('abort', abort, { once: true });
-        if (signal?.aborted) {
-            abort();
-            return;
-        }
-        child.send({ kind, root, request: { ...request, root: '.', path: leaf } }, error => {
-            if (error)
-                finish(computerFileError(error));
-        });
-    });
-}
-export async function readComputerFileSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerFilePath(root, request.path, false);
-    return execute('read', request, dirname(target), basename(target), signal, hooks);
-}
-export async function writeComputerFileSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerFilePath(root, request.path, request.mode === 'create');
-    return serialWrite(target, () => execute('write', request, dirname(target), basename(target), signal, hooks));
-}
-export async function listComputerDirSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const target = await resolveComputerDirPath(root, request.path);
-    // Listing the workspace root pins the worker at the root itself; '' is the zero-component leaf.
-    const anchor = target === root ? root : dirname(target);
-    const leaf = target === root ? '' : basename(target);
-    const data = await execute('ls', request, anchor, leaf, signal, hooks);
-    return { ...data, path: request.path };
-}
-export async function createComputerDirSafely(request, signal, hooks) {
-    const root = await realpath(request.root).catch(error => { throw computerFileError(error); });
-    const plan = await resolveComputerDirCreatePath(root, request.path, request.parents);
-    const data = await execute('mkdir', request, plan.anchor, plan.missing.join('/'), signal, hooks);
-    return { ...data, path: request.path };
-}

package/dist/workstation/qoderAdapter/taskEvent.js

@@ -1,26 +0,0 @@
-const id = (value) => typeof value === 'string' && value.length > 0 &&
-    Buffer.byteLength(value, 'utf8') <= 256 && !/[\x00-\x1f\x7f]/.test(value);
-const states = new Set(['pending', 'paused', 'running', 'completed', 'stopped', 'failed', 'unknown']);
-const terminal = new Set(['completed', 'stopped', 'failed']);
-export function parseTaskObservation(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const input = value;
-    if (['rootSessionId', 'runtimeGeneration', 'taskId', 'uuid'].some((key) => !id(input[key])) ||
-        !states.has(input.state) || typeof input.live !== 'boolean' ||
-        typeof input.stale !== 'boolean' || (terminal.has(input.state) && input.live) ||
-        ['agentId', 'launchingToolUseId'].some((key) => input[key] !== undefined && !id(input[key])) ||
-        (input.taskType !== undefined && (!id(input.taskType) || Buffer.byteLength(input.taskType, 'utf8') > 128)) ||
-        (input.background !== undefined && typeof input.background !== 'boolean') ||
-        (input.status !== undefined && (!terminal.has(input.status) || input.status !== input.state)) ||
-        (input.summary !== undefined && (typeof input.summary !== 'string' ||
-            Buffer.byteLength(input.summary, 'utf8') > 8192 || input.status === undefined)))
-        return undefined;
-    return Object.fromEntries(['rootSessionId', 'runtimeGeneration', 'taskId', 'uuid', 'state', 'live', 'stale',
-        'taskType', 'background', 'agentId', 'launchingToolUseId', 'status', 'summary']
-        .filter((key) => input[key] !== undefined).map((key) => [key, input[key]]));
-}
-export function taskEventMatchesHost(event, host) {
-    return host.selected && host.available && host.confirmed &&
-        event.rootSessionId === host.rootSessionId && event.runtimeGeneration === host.runtimeGeneration;
-}

package/dist/workstation/tools/core.js

@@ -1,50 +0,0 @@
-import os from 'node:os';
-import { StructuredFiles } from './files.js';
-import { PersistentTerminals } from './terminal.js';
-import { keys, validateRequest, TOOL_RESULT_BYTES } from './validation.js';
-/** All mutations are serialized across clients; shell processes continue independently. */
-export class ToolsCore {
-    files;
-    terminals;
-    queue = Promise.resolve();
-    disposed = false;
-    timer;
-    constructor(files, terminals, ttl) {
-        this.files = files;
-        this.terminals = terminals;
-        this.timer = setInterval(() => { this.queue = this.queue.then(() => this.files.expire()).catch(() => { }); }, Math.min(ttl, 60_000));
-        this.timer.unref();
-    }
-    static async create(options = {}) {
-        const files = await StructuredFiles.create(options.home ?? os.homedir(), options.roots ?? [], options.uploadTtlMs, options.uploadStateDir);
-        return new ToolsCore(files, new PersistentTerminals(files, options), options.uploadTtlMs ?? 15 * 60_000);
-    }
-    dispatch(method, params = {}) {
-        const task = this.queue.then(async () => {
-            if (this.disposed)
-                throw new Error('Workstation tools keeper stopped');
-            validateRequest(method, params);
-            let result;
-            if (method === 'tools.info') {
-                keys(params, []);
-                result = { version: 1, terminal: this.terminals.available, browser: false, files: true, home: this.files.home, roots: this.files.roots, downloads: this.files.downloads, ...(this.terminals.error ? { terminalError: this.terminals.error } : {}), browserError: 'Browser tools are not enabled in this release' };
-            }
-            else if (method.startsWith('terminal.'))
-                result = await this.terminals.dispatch(method, params);
-            else
-                result = await this.files.dispatch(method, params);
-            if (Buffer.byteLength(JSON.stringify(result)) > TOOL_RESULT_BYTES - 1024)
-                throw new Error('Tool result too large');
-            return result;
-        });
-        this.queue = task.catch(() => { });
-        return task;
-    }
-    async dispose() {
-        this.disposed = true;
-        clearInterval(this.timer);
-        await this.queue;
-        await this.terminals.dispose();
-        await this.files.dispose();
-    }
-}