terminal-quest 1.0.0

package/dist/engine/VirtualFS.js

@@ -0,0 +1,276 @@
+export class VirtualFS {
+    root;
+    cwd;
+    constructor(initialFS, initialCwd = '/') {
+        this.root = this.deepClone(initialFS);
+        this.cwd = initialCwd;
+    }
+    deepClone(node) {
+        if (node.type === 'file') {
+            return { type: 'file', content: node.content ?? '', permissions: node.permissions };
+        }
+        const children = {};
+        if (node.children) {
+            for (const [name, child] of Object.entries(node.children)) {
+                children[name] = this.deepClone(child);
+            }
+        }
+        return { type: 'directory', children, permissions: node.permissions };
+    }
+    getCwd() {
+        return this.cwd;
+    }
+    resolvePath(path) {
+        if (path.startsWith('/')) {
+            return this.normalizePath(path);
+        }
+        if (this.cwd === '/') {
+            return this.normalizePath('/' + path);
+        }
+        return this.normalizePath(this.cwd + '/' + path);
+    }
+    normalizePath(path) {
+        const parts = path.split('/').filter(Boolean);
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '.')
+                continue;
+            if (part === '..') {
+                resolved.pop();
+            }
+            else {
+                resolved.push(part);
+            }
+        }
+        return '/' + resolved.join('/');
+    }
+    getNode(path) {
+        const resolved = this.resolvePath(path);
+        if (resolved === '/')
+            return this.root;
+        const parts = resolved.split('/').filter(Boolean);
+        let current = this.root;
+        for (const part of parts) {
+            if (current.type !== 'directory' || !current.children?.[part]) {
+                return null;
+            }
+            current = current.children[part];
+        }
+        return current;
+    }
+    getParentAndName(path) {
+        const resolved = this.resolvePath(path);
+        if (resolved === '/')
+            return null;
+        const parts = resolved.split('/').filter(Boolean);
+        const name = parts.pop();
+        const parentPath = '/' + parts.join('/');
+        const parent = this.getNode(parentPath);
+        if (!parent || parent.type !== 'directory')
+            return null;
+        return { parent, name };
+    }
+    exists(path) {
+        return this.getNode(path) !== null;
+    }
+    isDirectory(path) {
+        const node = this.getNode(path);
+        return node != null && node.type === 'directory';
+    }
+    isFile(path) {
+        const node = this.getNode(path);
+        return node != null && node.type === 'file';
+    }
+    readFile(path) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such file: ${path}`);
+        if (node.type !== 'file')
+            throw new Error(`Is a directory: ${path}`);
+        return node.content ?? '';
+    }
+    writeFile(path, content) {
+        const existing = this.getNode(path);
+        if (existing) {
+            if (existing.type !== 'file')
+                throw new Error(`Is a directory: ${path}`);
+            existing.content = content;
+            return;
+        }
+        const info = this.getParentAndName(path);
+        if (!info)
+            throw new Error(`Cannot create file: ${path}`);
+        if (!info.parent.children)
+            info.parent.children = {};
+        info.parent.children[info.name] = { type: 'file', content };
+    }
+    appendFile(path, content) {
+        const existing = this.getNode(path);
+        if (existing) {
+            if (existing.type !== 'file')
+                throw new Error(`Is a directory: ${path}`);
+            existing.content = (existing.content ?? '') + content;
+            return;
+        }
+        this.writeFile(path, content);
+    }
+    listDir(path) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such directory: ${path}`);
+        if (node.type !== 'directory')
+            throw new Error(`Not a directory: ${path}`);
+        return Object.keys(node.children ?? {}).sort();
+    }
+    listDirDetailed(path) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such directory: ${path}`);
+        if (node.type !== 'directory')
+            throw new Error(`Not a directory: ${path}`);
+        return Object.entries(node.children ?? {})
+            .map(([name, child]) => ({ name, type: child.type }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    mkdir(path, recursive = false) {
+        if (this.exists(path)) {
+            if (this.isDirectory(path))
+                return;
+            throw new Error(`File exists: ${path}`);
+        }
+        if (recursive) {
+            const resolved = this.resolvePath(path);
+            const parts = resolved.split('/').filter(Boolean);
+            let current = '/';
+            for (const part of parts) {
+                current = current === '/' ? '/' + part : current + '/' + part;
+                if (!this.exists(current)) {
+                    this.mkdirSingle(current);
+                }
+                else if (!this.isDirectory(current)) {
+                    throw new Error(`Not a directory: ${current}`);
+                }
+            }
+        }
+        else {
+            this.mkdirSingle(path);
+        }
+    }
+    mkdirSingle(path) {
+        const info = this.getParentAndName(path);
+        if (!info)
+            throw new Error(`Cannot create directory: ${path}`);
+        if (!info.parent.children)
+            info.parent.children = {};
+        if (info.parent.children[info.name])
+            throw new Error(`Already exists: ${path}`);
+        info.parent.children[info.name] = { type: 'directory', children: {} };
+    }
+    remove(path, recursive = false) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such file or directory: ${path}`);
+        if (node.type === 'directory' && !recursive) {
+            const children = Object.keys(node.children ?? {});
+            if (children.length > 0) {
+                throw new Error(`Directory not empty: ${path}`);
+            }
+        }
+        const info = this.getParentAndName(path);
+        if (!info)
+            throw new Error(`Cannot remove root`);
+        delete info.parent.children[info.name];
+    }
+    copy(src, dest, recursive = false) {
+        const srcNode = this.getNode(src);
+        if (!srcNode)
+            throw new Error(`No such file or directory: ${src}`);
+        if (srcNode.type === 'directory' && !recursive) {
+            throw new Error(`Is a directory (use -r): ${src}`);
+        }
+        const cloned = this.deepClone(srcNode);
+        if (this.exists(dest) && this.isDirectory(dest)) {
+            const srcParts = this.resolvePath(src).split('/').filter(Boolean);
+            const srcName = srcParts[srcParts.length - 1];
+            const destNode = this.getNode(dest);
+            if (!destNode.children)
+                destNode.children = {};
+            destNode.children[srcName] = cloned;
+        }
+        else {
+            const info = this.getParentAndName(dest);
+            if (!info)
+                throw new Error(`Cannot copy to: ${dest}`);
+            if (!info.parent.children)
+                info.parent.children = {};
+            info.parent.children[info.name] = cloned;
+        }
+    }
+    move(src, dest) {
+        const srcNode = this.getNode(src);
+        if (!srcNode)
+            throw new Error(`No such file or directory: ${src}`);
+        const cloned = this.deepClone(srcNode);
+        if (this.exists(dest) && this.isDirectory(dest)) {
+            const srcParts = this.resolvePath(src).split('/').filter(Boolean);
+            const srcName = srcParts[srcParts.length - 1];
+            const destNode = this.getNode(dest);
+            if (!destNode.children)
+                destNode.children = {};
+            destNode.children[srcName] = cloned;
+        }
+        else {
+            const info = this.getParentAndName(dest);
+            if (!info)
+                throw new Error(`Cannot move to: ${dest}`);
+            if (!info.parent.children)
+                info.parent.children = {};
+            info.parent.children[info.name] = cloned;
+        }
+        const srcInfo = this.getParentAndName(src);
+        if (srcInfo) {
+            delete srcInfo.parent.children[srcInfo.name];
+        }
+    }
+    changeCwd(path) {
+        const resolved = this.resolvePath(path);
+        const node = this.getNode(resolved);
+        if (!node)
+            throw new Error(`No such directory: ${path}`);
+        if (node.type !== 'directory')
+            throw new Error(`Not a directory: ${path}`);
+        this.cwd = resolved;
+    }
+    getPermissions(path) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such file or directory: ${path}`);
+        return node.permissions ?? (node.type === 'directory' ? 'drwxr-xr-x' : '-rw-r--r--');
+    }
+    setPermissions(path, permissions) {
+        const node = this.getNode(path);
+        if (!node)
+            throw new Error(`No such file or directory: ${path}`);
+        node.permissions = permissions;
+    }
+    find(startPath, predicate) {
+        const results = [];
+        const resolved = this.resolvePath(startPath);
+        const walk = (currentPath, node) => {
+            if (predicate(currentPath, node)) {
+                results.push(currentPath);
+            }
+            if (node.type === 'directory' && node.children) {
+                for (const [name, child] of Object.entries(node.children)) {
+                    walk(currentPath === '/' ? '/' + name : currentPath + '/' + name, child);
+                }
+            }
+        };
+        const startNode = this.getNode(resolved);
+        if (startNode) {
+            walk(resolved, startNode);
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=VirtualFS.js.map

package/dist/engine/commands/cat.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function cat(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=cat.d.ts.map

package/dist/engine/commands/cat.js

@@ -0,0 +1,18 @@
+export function cat(fs, args) {
+    if (args.length === 0) {
+        return { output: '', error: 'cat: missing file operand' };
+    }
+    const outputs = [];
+    for (const filePath of args) {
+        try {
+            const content = fs.readFile(filePath);
+            outputs.push(content);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return { output: '', error: `cat: ${msg}` };
+        }
+    }
+    return { output: outputs.join('') };
+}
+//# sourceMappingURL=cat.js.map

package/dist/engine/commands/cd.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function cd(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=cd.d.ts.map

package/dist/engine/commands/cd.js

@@ -0,0 +1,12 @@
+export function cd(fs, args) {
+    const target = args[0] ?? '/';
+    try {
+        fs.changeCwd(target);
+        return { output: '' };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { output: '', error: `cd: ${msg}` };
+    }
+}
+//# sourceMappingURL=cd.js.map

package/dist/engine/commands/chmod.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function chmod(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=chmod.d.ts.map

package/dist/engine/commands/chmod.js

@@ -0,0 +1,98 @@
+export function chmod(fs, args) {
+    if (args.length < 2) {
+        return { output: '', error: 'chmod: missing operand' };
+    }
+    const modeStr = args[0];
+    const filePath = args[1];
+    if (!fs.exists(filePath)) {
+        return { output: '', error: `chmod: cannot access '${filePath}': No such file or directory` };
+    }
+    const currentPerms = fs.getPermissions(filePath);
+    let newPerms;
+    // Check if numeric mode (e.g., 755, 644)
+    if (/^\d{3,4}$/.test(modeStr)) {
+        newPerms = numericToSymbolic(modeStr, fs.isDirectory(filePath));
+    }
+    else {
+        // Symbolic mode (e.g., +x, u+w, go-r)
+        newPerms = applySymbolicMode(currentPerms, modeStr);
+        if (!newPerms) {
+            return { output: '', error: `chmod: invalid mode: '${modeStr}'` };
+        }
+    }
+    try {
+        fs.setPermissions(filePath, newPerms);
+    }
+    catch (e) {
+        return { output: '', error: `chmod: ${e.message}` };
+    }
+    return { output: '' };
+}
+function numericToSymbolic(mode, isDir) {
+    // Take last 3 digits
+    const digits = mode.slice(-3);
+    const prefix = isDir ? 'd' : '-';
+    const perms = digits.split('').map(d => {
+        const n = parseInt(d, 10);
+        return (((n & 4) ? 'r' : '-') +
+            ((n & 2) ? 'w' : '-') +
+            ((n & 1) ? 'x' : '-'));
+    });
+    return prefix + perms.join('');
+}
+function applySymbolicMode(current, modeStr) {
+    // Parse symbolic mode: [ugoa][+-=][rwx]
+    const chars = current.split('');
+    // Support multiple comma-separated modes
+    const modes = modeStr.split(',');
+    for (const mode of modes) {
+        const match = mode.match(/^([ugoa]*)([-+=])([rwx]+)$/);
+        if (!match)
+            return '';
+        let who = match[1];
+        const op = match[2];
+        const perms = match[3];
+        // If no who specified, default to 'a' (all)
+        if (who === '' || who === 'a') {
+            who = 'ugo';
+        }
+        for (const w of who) {
+            let offset;
+            if (w === 'u')
+                offset = 1;
+            else if (w === 'g')
+                offset = 4;
+            else if (w === 'o')
+                offset = 7;
+            else
+                continue;
+            for (const p of perms) {
+                let permOffset;
+                if (p === 'r')
+                    permOffset = 0;
+                else if (p === 'w')
+                    permOffset = 1;
+                else if (p === 'x')
+                    permOffset = 2;
+                else
+                    continue;
+                const idx = offset + permOffset;
+                if (op === '+') {
+                    chars[idx] = p;
+                }
+                else if (op === '-') {
+                    chars[idx] = '-';
+                }
+                else if (op === '=') {
+                    // First clear all, then set
+                    chars[offset] = '-';
+                    chars[offset + 1] = '-';
+                    chars[offset + 2] = '-';
+                    chars[idx] = p;
+                }
+            }
+        }
+    }
+    return chars.join('');
+}
+//# sourceMappingURL=chmod.js.map

package/dist/engine/commands/clear.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function clear(_fs: VirtualFS, _args: string[]): CommandResult;
+//# sourceMappingURL=clear.d.ts.map

package/dist/engine/commands/clear.js

@@ -0,0 +1,4 @@
+export function clear(_fs, _args) {
+    return { output: 'CLEAR_SCREEN' };
+}
+//# sourceMappingURL=clear.js.map

package/dist/engine/commands/cp.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function cp(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=cp.d.ts.map

package/dist/engine/commands/cp.js

@@ -0,0 +1,26 @@
+export function cp(fs, args) {
+    let recursive = false;
+    const paths = [];
+    for (const arg of args) {
+        if (arg === '-r' || arg === '-R' || arg === '--recursive') {
+            recursive = true;
+        }
+        else {
+            paths.push(arg);
+        }
+    }
+    if (paths.length < 2) {
+        return { output: '', error: 'cp: missing file operand' };
+    }
+    const src = paths[0];
+    const dest = paths[1];
+    try {
+        fs.copy(src, dest, recursive);
+        return { output: '' };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { output: '', error: `cp: ${msg}` };
+    }
+}
+//# sourceMappingURL=cp.js.map

package/dist/engine/commands/cut.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function cut(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=cut.d.ts.map

package/dist/engine/commands/cut.js

@@ -0,0 +1,76 @@
+export function cut(fs, args) {
+    // Extract stdin
+    let stdin;
+    const stdinIdx = args.findIndex(a => a.startsWith('__stdin__:'));
+    if (stdinIdx !== -1) {
+        stdin = args[stdinIdx].slice('__stdin__:'.length);
+        args = [...args.slice(0, stdinIdx), ...args.slice(stdinIdx + 1)];
+    }
+    let delimiter = '\t';
+    let fieldsStr;
+    const files = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-d') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'cut: option requires an argument -- d' };
+            }
+            delimiter = args[i];
+        }
+        else if (arg.startsWith('-d')) {
+            delimiter = arg.slice(2);
+        }
+        else if (arg === '-f') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'cut: option requires an argument -- f' };
+            }
+            fieldsStr = args[i];
+        }
+        else if (arg.startsWith('-f')) {
+            fieldsStr = arg.slice(2);
+        }
+        else if (arg.startsWith('-')) {
+            return { output: '', error: `cut: invalid option -- '${arg}'` };
+        }
+        else {
+            files.push(arg);
+        }
+    }
+    if (!fieldsStr) {
+        return { output: '', error: 'cut: you must specify a list of fields' };
+    }
+    // Parse field numbers (1-based, comma-separated)
+    const fields = fieldsStr.split(',').map(f => {
+        const n = parseInt(f.trim(), 10);
+        if (isNaN(n) || n < 1)
+            return -1;
+        return n;
+    });
+    if (fields.some(f => f === -1)) {
+        return { output: '', error: `cut: invalid field value '${fieldsStr}'` };
+    }
+    let content;
+    if (files.length > 0) {
+        try {
+            content = fs.readFile(files[0]);
+        }
+        catch (e) {
+            return { output: '', error: `cut: ${e.message}` };
+        }
+    }
+    else if (stdin !== undefined) {
+        content = stdin;
+    }
+    else {
+        return { output: '', error: 'cut: missing file operand' };
+    }
+    const lines = content.split('\n');
+    const result = lines.map(line => {
+        const parts = line.split(delimiter);
+        return fields.map(f => parts[f - 1] ?? '').join(delimiter);
+    });
+    return { output: result.join('\n') };
+}
+//# sourceMappingURL=cut.js.map

package/dist/engine/commands/echo.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function echo(_fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=echo.d.ts.map

package/dist/engine/commands/echo.js

@@ -0,0 +1,4 @@
+export function echo(_fs, args) {
+    return { output: args.join(' ') };
+}
+//# sourceMappingURL=echo.js.map

package/dist/engine/commands/find.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function find(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=find.d.ts.map

package/dist/engine/commands/find.js

@@ -0,0 +1,60 @@
+export function find(fs, args) {
+    let searchPath = '.';
+    let namePattern;
+    let typeFilter;
+    let i = 0;
+    // First non-flag argument is the path (if it doesn't start with -)
+    if (i < args.length && !args[i].startsWith('-')) {
+        searchPath = args[i];
+        i++;
+    }
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '-name') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'find: missing argument to -name' };
+            }
+            namePattern = args[i];
+        }
+        else if (arg === '-type') {
+            i++;
+            if (i >= args.length) {
+                return { output: '', error: 'find: missing argument to -type' };
+            }
+            const t = args[i];
+            if (t !== 'f' && t !== 'd') {
+                return { output: '', error: `find: invalid type '${t}'` };
+            }
+            typeFilter = t;
+        }
+        else {
+            return { output: '', error: `find: unknown option '${arg}'` };
+        }
+        i++;
+    }
+    if (!fs.exists(searchPath)) {
+        return { output: '', error: `find: '${searchPath}': No such file or directory` };
+    }
+    const results = fs.find(searchPath, (path, node) => {
+        if (typeFilter === 'f' && node.type !== 'file')
+            return false;
+        if (typeFilter === 'd' && node.type !== 'directory')
+            return false;
+        if (namePattern !== undefined) {
+            const name = path.split('/').filter(Boolean).pop() ?? '';
+            if (path === '/' && !namePattern)
+                return false;
+            return matchWildcard(name, namePattern);
+        }
+        return true;
+    });
+    return { output: results.join('\n') };
+}
+function matchWildcard(str, pattern) {
+    // Convert wildcard pattern to regex
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const regexStr = '^' + escaped.replace(/\*/g, '.*').replace(/\?/g, '.') + '$';
+    return new RegExp(regexStr).test(str);
+}
+//# sourceMappingURL=find.js.map

package/dist/engine/commands/git.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFS } from '../VirtualFS.js';
+import type { CommandResult } from './index.js';
+export declare function git(fs: VirtualFS, args: string[]): CommandResult;
+//# sourceMappingURL=git.d.ts.map