nexus-ai-pro 2.6.0 → 2.7.0

package/dist/agent/interpreter.js

@@ -0,0 +1,270 @@
+import { capabilitiesOf } from './capabilities.js';
+import { isToolOutput, ToolExecutor } from './tool.js';
+export function workerInterpreter(options = {}) {
+    const maxLog = options.maxLogChars ?? 64_000;
+    const maxCalls = options.maxCalls ?? 100;
+    return {
+        name: 'worker (not a security boundary)',
+        language: 'JavaScript',
+        async run(code, runOptions = {}) {
+            const { Worker } = await import('node:worker_threads');
+            const started = Date.now();
+            const tools = runOptions.tools ?? {};
+            const logs = [];
+            const calls = [];
+            let logged = 0;
+            return new Promise((resolve) => {
+                const memory = options.memoryMb ?? 64;
+                const worker = new Worker(WORKER_SOURCE, {
+                    eval: true,
+                    workerData: { code },
+                    resourceLimits: {
+                        maxOldGenerationSizeMb: memory,
+                        maxYoungGenerationSizeMb: Math.max(4, Math.ceil(memory / 8)),
+                    },
+                    stdout: true,
+                    stderr: true,
+                });
+                let settled = false;
+                const finish = (result) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    runOptions.signal?.removeEventListener('abort', onAbort);
+                    void worker.terminate();
+                    resolve({ ...result, logs, calls, durationMs: Date.now() - started });
+                };
+                const limit = runOptions.timeoutMs ?? options.timeoutMs ?? 10_000;
+                const timer = setTimeout(() => finish({ ok: false, error: `The code ran past its ${limit} ms timeout`, timedOut: true }), limit);
+                const onAbort = () => finish({ ok: false, error: 'The run was aborted', timedOut: false });
+                if (runOptions.signal?.aborted)
+                    onAbort();
+                runOptions.signal?.addEventListener('abort', onAbort, { once: true });
+                worker.on('message', (message) => {
+                    if (message.type === 'log') {
+                        if (logged >= maxLog)
+                            return;
+                        const line = message.line.slice(0, maxLog - logged);
+                        logged += line.length;
+                        logs.push(line);
+                    }
+                    else if (message.type === 'call') {
+                        void answer(message);
+                    }
+                    else if (message.type === 'done') {
+                        finish(message.ok
+                            ? { ok: true, value: message.value, timedOut: false }
+                            : { ok: false, error: message.error, timedOut: false });
+                    }
+                });
+                worker.on('error', (error) => {
+                    const outOfMemory = error.code === 'ERR_WORKER_OUT_OF_MEMORY';
+                    finish({
+                        ok: false,
+                        error: outOfMemory ? `The code ran out of memory, past ${memory} MB` : error.message,
+                        timedOut: false,
+                    });
+                });
+                worker.on('exit', () => finish({ ok: false, error: 'The interpreter stopped', timedOut: false }));
+                const answer = async (message) => {
+                    const reply = (body) => {
+                        if (settled)
+                            return;
+                        try {
+                            worker.postMessage({ type: 'result', id: message.id, ...body });
+                        }
+                        catch {
+                            worker.postMessage({ type: 'result', id: message.id, ...body, value: toJson(body) });
+                        }
+                    };
+                    const fn = Object.hasOwn(tools, message.name) ? tools[message.name] : undefined;
+                    if (calls.length >= maxCalls) {
+                        calls.push({ name: message.name, args: message.args, ok: false });
+                        reply({ ok: false, error: `The code made more than ${maxCalls} calls` });
+                        return;
+                    }
+                    const call = { name: message.name, args: message.args, ok: false };
+                    calls.push(call);
+                    if (!fn) {
+                        reply({ ok: false, error: `There is no tool named ${message.name}; the tools are ${namesOf(tools)}` });
+                        return;
+                    }
+                    try {
+                        const value = await fn((message.args ?? {}));
+                        call.ok = true;
+                        reply({ ok: true, value });
+                    }
+                    catch (error) {
+                        reply({ ok: false, error: error instanceof Error ? error.message : String(error) });
+                    }
+                };
+            });
+        },
+    };
+}
+const namesOf = (tools) => Object.keys(tools).join(', ') || 'none';
+function toJson(body) {
+    try {
+        return JSON.parse(JSON.stringify(body.value ?? null));
+    }
+    catch {
+        return String(body.value);
+    }
+}
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+const pending = new Map();
+let next = 0;
+const show = (value) => {
+  if (typeof value === 'string') return value;
+  try { return JSON.stringify(value); } catch { return String(value); }
+};
+const say = (...values) => parentPort.postMessage({ type: 'log', line: values.map(show).join(' ') });
+const console = { log: say, info: say, warn: say, error: say, debug: say };
+const tools = new Proxy({}, {
+  get(_target, name) {
+    if (typeof name !== 'string' || name === 'then') return undefined;
+    return (args = {}) => new Promise((resolve, reject) => {
+      const id = next++;
+      pending.set(id, { resolve, reject });
+      parentPort.postMessage({ type: 'call', id, name, args });
+    });
+  },
+});
+parentPort.on('message', (message) => {
+  if (message.type !== 'result') return;
+  const waiting = pending.get(message.id);
+  pending.delete(message.id);
+  if (!waiting) return;
+  if (message.ok) waiting.resolve(message.value);
+  else waiting.reject(new Error(message.error));
+});
+const AsyncFunction = (async () => {}).constructor;
+(async () => {
+  try {
+    const value = await new AsyncFunction('tools', 'console', workerData.code)(tools, console);
+    try {
+      parentPort.postMessage({ type: 'done', ok: true, value });
+    } catch {
+      parentPort.postMessage({ type: 'done', ok: true, value: show(value) });
+    }
+  } catch (error) {
+    parentPort.postMessage({ type: 'done', ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+})();
+`;
+export function codeTool(interpreter, options) {
+    const executor = new ToolExecutor([...options.tools]);
+    const listed = options.tools
+        .map((tool) => `- ${tool.name}(${JSON.stringify(tool.parameters)}): ${tool.description}`)
+        .join('\n');
+    return {
+        name: options.name ?? 'run_code',
+        description: `Runs ${interpreter.language} code in one step: the body of an async function. Call the tools below with \`await tools.<name>(args)\`, \`return\` the value you need, and use console.log for notes. Use it to call tools many times, at once, or to filter what they return before you read it.\nTools:\n${listed || '- none'}`,
+        parameters: {
+            type: 'object',
+            properties: { code: { type: 'string', description: `The ${interpreter.language} to run` } },
+            required: ['code'],
+        },
+        capabilities: ['code'],
+        execute: async (args, context) => {
+            const tools = {};
+            for (const definition of options.tools) {
+                tools[definition.name] = async (callArgs) => {
+                    if (options.permissions) {
+                        const verdict = await options.permissions.decide({
+                            tool: definition.name,
+                            args: callArgs,
+                            capabilities: capabilitiesOf(definition, callArgs),
+                            ...(context?.principal ? { principal: context.principal } : {}),
+                        });
+                        if (verdict.decision === 'deny')
+                            throw new Error(`Permission denied: ${verdict.reason}`);
+                        if (verdict.decision === 'ask') {
+                            throw new Error(`${definition.name} needs a person's approval, so call it directly: ${verdict.reason}`);
+                        }
+                    }
+                    const result = await executor.execute(definition.name, callArgs, context);
+                    if (!result.ok)
+                        throw new Error(result.error);
+                    return isToolOutput(result.result)
+                        ? result.result.content.map((part) => (part.type === 'text' ? part.text : `[${part.type}]`)).join('\n')
+                        : result.result;
+                };
+            }
+            const outcome = await interpreter.run(String(args.code ?? ''), {
+                tools,
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                ...(context?.signal ? { signal: context.signal } : {}),
+            });
+            return {
+                ok: outcome.ok,
+                ...(outcome.ok ? { value: outcome.value ?? null } : { error: outcome.error }),
+                ...(outcome.logs.length ? { logs: outcome.logs } : {}),
+                calls: outcome.calls.map((call) => `${call.name}${call.ok ? '' : ' (failed)'}`),
+            };
+        },
+    };
+}
+export async function runInterpreterConformance(interpreter) {
+    const checks = [];
+    const check = async (name, run) => {
+        try {
+            const problem = await run();
+            checks.push(problem ? { name, ok: false, detail: problem } : { name, ok: true });
+        }
+        catch (error) {
+            checks.push({ name, ok: false, detail: error instanceof Error ? error.message : String(error) });
+        }
+    };
+    const same = (actual, expected, what) => JSON.stringify(actual) === JSON.stringify(expected)
+        ? undefined
+        : `${what}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`;
+    const double = async (args) => Number(args.n) * 2;
+    await check('code returns a value, logs, and calls tools in order and at once', async () => {
+        const result = await interpreter.run(`const one = await tools.double({ n: 1 });
+       const many = await Promise.all([2, 3].map((n) => tools.double({ n })));
+       console.log('doubled', one, many);
+       return { one, many };`, { tools: { double } });
+        return (same(result.ok, true, `ok (${result.error})`) ??
+            same(result.value, { one: 2, many: [4, 6] }, 'value') ??
+            same(result.logs, ['doubled 2 [4,6]'], 'logs') ??
+            same(result.calls.map((call) => call.name), ['double', 'double', 'double'], 'calls'));
+    });
+    await check('a failing tool rejects in the code, and an unknown tool fails', async () => {
+        const fail = async () => {
+            throw new Error('no such order');
+        };
+        const result = await interpreter.run(`let caught = '';
+       try { await tools.lookup({ id: 1 }); } catch (error) { caught = error.message; }
+       let unknown = '';
+       try { await tools.missing({}); } catch (error) { unknown = error.message; }
+       return { caught, unknown: unknown.length > 0 };`, { tools: { lookup: fail } });
+        return same(result.value, { caught: 'no such order', unknown: true }, 'value');
+    });
+    await check('code that throws is reported', async () => {
+        const result = await interpreter.run(`throw new Error('broken on purpose');`);
+        return (same(result.ok, false, 'ok') ??
+            (result.error?.includes('broken on purpose') ? undefined : `error: ${result.error}`));
+    });
+    await check('an endless loop is stopped at the timeout', async () => {
+        const result = await interpreter.run('while (true) {}', { timeoutMs: 300 });
+        if (!result.timedOut || result.ok)
+            return `the loop was not reported as timed out: ${JSON.stringify(result)}`;
+        const after = await interpreter.run('return 1 + 1;');
+        return same(after.value, 2, 'a run after the timeout');
+    });
+    await check('a runaway allocation is stopped', async () => {
+        const result = await interpreter.run('const kept = []; for (;;) kept.push(new Array(1e6).fill(Math.random()));', {
+            timeoutMs: 30_000,
+        });
+        if (result.ok)
+            return 'the allocation finished';
+        if (result.timedOut)
+            return 'the allocation ran to the timeout instead of meeting a memory limit';
+        const after = await interpreter.run('return 1 + 1;');
+        return same(after.value, 2, 'a run after the allocation');
+    });
+    return { interpreter: interpreter.name, passed: checks.every((item) => item.ok), checks };
+}

package/dist/agent/sandbox-container.d.ts

@@ -0,0 +1,48 @@
+import { type Sandbox } from './sandbox.js';
+/** Options for `containerSandbox()`. */
+export interface ContainerSandboxOptions {
+    /**
+     * The image, such as `node:22-alpine`. It needs a POSIX shell, `cat`, `find`, `tar`, and the
+     * commands the agent is to run.
+     */
+    image: string;
+    /** The binary that runs containers: `docker`, `podman`, or a path to either. Defaults to `docker`. */
+    binary?: string;
+    /** Where the files live inside the container, and where commands run. Defaults to `/workspace`. */
+    workdir?: string;
+    /**
+     * The network. `false`, the default, gives the container none at all; `true` gives it the
+     * runtime's default network; a string names a network to join.
+     */
+    network?: boolean | string;
+    /** The memory limit, as the runtime takes it. Swap is held to the same limit. Defaults to `512m`. */
+    memory?: string;
+    /** How many CPUs it may use. Defaults to 1. */
+    cpus?: number;
+    /** The most processes it may run at once. Defaults to 256. */
+    pids?: number;
+    /** Environment variables every command gets, on top of the image's own. */
+    env?: Record<string, string>;
+    /** The timeout for a command that sets none. Defaults to 30 seconds. */
+    timeoutMs?: number;
+    /** Output kept per stream, in bytes. Defaults to 1 MB. */
+    maxOutputBytes?: number;
+    /**
+     * More arguments for `run`, before the image, for what these options do not cover, such as
+     * `--user` with a volume that user can write.
+     */
+    runArgs?: readonly string[];
+}
+/**
+ * A sandbox in a container, for production. Every command runs through `exec` in one container per
+ * sandbox, and a command past its timeout is killed inside the container with everything it
+ * started. `isolation` reports the network as isolated only when the container has none.
+ *
+ * ```ts
+ * const sandbox = containerSandbox({ image: 'node:22-alpine' });
+ * const agent = createDeepAgent({ client: ai, sandbox, commands: ['node', 'npm test'] });
+ * // …
+ * await sandbox.dispose?.();
+ * ```
+ */
+export declare function containerSandbox(options: ContainerSandboxOptions): Sandbox;

package/dist/agent/sandbox-container.js

@@ -0,0 +1,291 @@
+import { GREP_FILE_BYTES, GREP_TOTAL_BYTES, globMatcher, matchingLines, WALK_LIMIT } from './glob.js';
+import { SandboxPathError, } from './sandbox.js';
+export function containerSandbox(options) {
+    const binary = options.binary ?? 'docker';
+    const workdir = `/${(options.workdir ?? '/workspace').replace(/^\/+|\/+$/g, '')}`;
+    const maxOutput = options.maxOutputBytes ?? 1_048_576;
+    const network = options.network ?? false;
+    const label = `nexus-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    let marks = 0;
+    const inside = (file) => {
+        const unified = file.replace(/\\/g, '/');
+        if (unified.includes('\0'))
+            throw new SandboxPathError(file);
+        const parts = [];
+        for (const segment of (unified.startsWith('/') ? unified : `${workdir}/${unified}`).split('/')) {
+            if (segment === '' || segment === '.')
+                continue;
+            if (segment !== '..')
+                parts.push(segment);
+            else if (parts.pop() === undefined)
+                throw new SandboxPathError(file);
+        }
+        const resolved = `/${parts.join('/')}`;
+        if (resolved !== workdir && !resolved.startsWith(`${workdir}/`))
+            throw new SandboxPathError(file);
+        return resolved;
+    };
+    const fromRoot = (path) => (path === workdir ? '.' : path.slice(workdir.length + 1));
+    const invoke = async (args, call = {}) => {
+        const { spawn } = await import('node:child_process');
+        return new Promise((resolve) => {
+            const child = spawn(binary, args, { windowsHide: true });
+            const out = [];
+            let kept = 0;
+            let stderr = '';
+            let timedOut = false;
+            let settled = false;
+            child.stdout.on('data', (chunk) => {
+                const room = (call.keep ?? Number.POSITIVE_INFINITY) - kept;
+                if (room <= 0)
+                    return;
+                const part = chunk.byteLength > room ? chunk.subarray(0, room) : chunk;
+                out.push(part);
+                kept += part.byteLength;
+            });
+            child.stderr.on('data', (chunk) => {
+                if (stderr.length < maxOutput)
+                    stderr = (stderr + new TextDecoder().decode(chunk)).slice(0, maxOutput);
+            });
+            const stop = () => {
+                call.onStop?.();
+                child.kill('SIGKILL');
+            };
+            const timer = call.timeoutMs === undefined
+                ? undefined
+                : setTimeout(() => {
+                    timedOut = true;
+                    stop();
+                }, call.timeoutMs);
+            call.signal?.addEventListener('abort', stop, { once: true });
+            const finish = (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                call.signal?.removeEventListener('abort', stop);
+                resolve({ code: timedOut ? null : code, stdout: concat(out), stderr, timedOut });
+            };
+            child.on('error', (error) => {
+                stderr += error.message;
+                finish(null);
+            });
+            child.on('close', (code) => finish(code));
+            child.stdin.on('error', () => undefined);
+            child.stdin.end(call.stdin ?? '');
+        });
+    };
+    const failed = (what, result) => new Error(`${what} failed in the container: ${result.stderr.trim() || `exit code ${result.code}`}`);
+    let started;
+    const container = () => {
+        if (started)
+            return started;
+        const starting = (async () => {
+            const result = await invoke([
+                'run',
+                '--detach',
+                '--rm',
+                '--init',
+                '--name',
+                label,
+                '--label',
+                'nexus-ai-pro.sandbox=1',
+                '--workdir',
+                workdir,
+                ...(network === true ? [] : ['--network', network === false ? 'none' : network]),
+                '--memory',
+                options.memory ?? '512m',
+                '--memory-swap',
+                options.memory ?? '512m',
+                '--cpus',
+                String(options.cpus ?? 1),
+                '--pids-limit',
+                String(options.pids ?? 256),
+                '--cap-drop',
+                'ALL',
+                '--security-opt',
+                'no-new-privileges',
+                ...envArgs(options.env),
+                ...(options.runArgs ?? []),
+                '--entrypoint',
+                'tail',
+                options.image,
+                '-f',
+                '/dev/null',
+            ]);
+            if (result.code !== 0)
+                throw failed(`Starting ${options.image}`, result);
+            return new TextDecoder().decode(result.stdout).trim();
+        })();
+        started = starting;
+        starting.catch(() => {
+            if (started === starting)
+                started = undefined;
+        });
+        return starting;
+    };
+    const shell = async (script, args, stdin, keep) => {
+        const id = await container();
+        return invoke(['exec', ...(stdin === undefined ? [] : ['--interactive']), id, 'sh', '-c', script, 'sh', ...args], {
+            ...(stdin === undefined ? {} : { stdin }),
+            ...(keep === undefined ? {} : { keep }),
+        });
+    };
+    const walk = async (directory, filter = '') => {
+        const start = inside(directory);
+        const result = await shell(`find "$1" \\( -name .git -o -name node_modules \\) -prune -o -type f ${filter} -print`, [start]);
+        if (result.code !== 0 && result.stdout.byteLength === 0)
+            throw failed('Listing files', result);
+        return new TextDecoder()
+            .decode(result.stdout)
+            .split('\n')
+            .filter(Boolean)
+            .slice(0, WALK_LIMIT)
+            .map((path) => ({ fromRoot: fromRoot(path), fromStart: path.slice(start.length).replace(/^\//, '') }))
+            .sort((a, b) => (a.fromRoot < b.fromRoot ? -1 : a.fromRoot > b.fromRoot ? 1 : 0));
+    };
+    const readBytes = async (file) => {
+        const result = await shell('cat "$1"', [inside(file)]);
+        if (result.code !== 0)
+            throw failed(`Reading ${file}`, result);
+        return result.stdout;
+    };
+    return {
+        name: `container (${binary} ${options.image})`,
+        isolation: { filesystem: true, network: network === false, processes: true },
+        async exec(command, execOptions = {}) {
+            const id = await container();
+            const startedAt = Date.now();
+            const mark = `${label}-${++marks}`;
+            const result = await invoke([
+                'exec',
+                '--interactive',
+                '--workdir',
+                inside(execOptions.cwd ?? '.'),
+                ...envArgs({ ...options.env, ...execOptions.env, NEXUS_SANDBOX_EXEC: mark }),
+                id,
+                'sh',
+                '-c',
+                command,
+            ], {
+                stdin: execOptions.stdin ?? '',
+                keep: maxOutput,
+                timeoutMs: execOptions.timeoutMs ?? options.timeoutMs ?? 30_000,
+                ...(execOptions.signal ? { signal: execOptions.signal } : {}),
+                onStop: () => {
+                    void invoke(['exec', id, 'sh', '-c', KILL_MARKED, 'sh', mark]);
+                },
+            });
+            return {
+                exitCode: result.code,
+                stdout: new TextDecoder().decode(result.stdout),
+                stderr: result.stderr,
+                timedOut: result.timedOut,
+                durationMs: Date.now() - startedAt,
+            };
+        },
+        async readFile(file) {
+            return new TextDecoder().decode(await readBytes(file));
+        },
+        readBytes,
+        async writeFile(file, content) {
+            const result = await shell('mkdir -p "$(dirname "$1")" && cat > "$1"', [inside(file)], content);
+            if (result.code !== 0)
+                throw failed(`Writing ${file}`, result);
+        },
+        async listFiles(directory = '.') {
+            const result = await shell('ls -1A "$1"', [inside(directory)]);
+            if (result.code !== 0)
+                throw failed(`Listing ${directory}`, result);
+            return new TextDecoder().decode(result.stdout).split('\n').filter(Boolean).sort();
+        },
+        async removeFile(file) {
+            const target = inside(file);
+            if (target === workdir)
+                throw new SandboxPathError(file);
+            const result = await shell('rm -rf "$1"', [target]);
+            if (result.code !== 0)
+                throw failed(`Removing ${file}`, result);
+        },
+        async glob(pattern, globOptions = {}) {
+            const matches = globMatcher(pattern);
+            return (await walk(globOptions.cwd ?? '.'))
+                .filter((file) => matches(file.fromStart))
+                .slice(0, globOptions.limit ?? 1_000)
+                .map((file) => file.fromRoot);
+        },
+        async grep(pattern, grepOptions = {}) {
+            const expression = new RegExp(pattern, grepOptions.ignoreCase ? 'i' : '');
+            const only = grepOptions.glob ? globMatcher(grepOptions.glob) : undefined;
+            const limit = grepOptions.limit ?? 200;
+            const candidates = (await walk(grepOptions.cwd ?? '.', `-size -${GREP_FILE_BYTES / 1024 + 1}k`)).filter((file) => !only || only(file.fromStart));
+            const found = [];
+            let read = 0;
+            for (let index = 0; index < candidates.length && found.length < limit && read < GREP_TOTAL_BYTES; index += 200) {
+                const batch = candidates.slice(index, index + 200).map((file) => `./${file.fromRoot}`);
+                const result = await shell('cd "$1" && shift && tar -cf - "$@"', [workdir, ...batch], undefined, GREP_TOTAL_BYTES - read);
+                for (const entry of untar(result.stdout)) {
+                    read += entry.data.byteLength;
+                    const file = entry.name.replace(/^\.\//, '');
+                    found.push(...matchingLines(entry.data, expression, limit - found.length).map((match) => ({ file, ...match })));
+                    if (found.length >= limit)
+                        break;
+                }
+            }
+            return found;
+        },
+        async dispose() {
+            const current = started;
+            started = undefined;
+            const id = await current?.catch(() => undefined);
+            if (id)
+                await invoke(['rm', '--force', id]);
+        },
+    };
+}
+const KILL_MARKED = 'for p in /proc/[0-9]*; do if tr "\\000" "\\n" < "$p/environ" 2>/dev/null | grep -qx "NEXUS_SANDBOX_EXEC=$1"; then kill -9 "$(basename "$p")" 2>/dev/null; fi; done; true';
+function envArgs(env) {
+    return Object.entries(env ?? {}).flatMap(([key, value]) => ['--env', `${key}=${value}`]);
+}
+function concat(chunks) {
+    const bytes = new Uint8Array(chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function untar(tar) {
+    const decoder = new TextDecoder();
+    const field = (from, length) => {
+        const bytes = tar.subarray(from, from + length);
+        const end = bytes.indexOf(0);
+        return decoder.decode(end < 0 ? bytes : bytes.subarray(0, end));
+    };
+    const files = [];
+    let offset = 0;
+    let longName;
+    while (offset + 512 <= tar.byteLength) {
+        if (tar.subarray(offset, offset + 512).every((byte) => byte === 0))
+            break;
+        const size = Number.parseInt(field(offset + 124, 12).trim() || '0', 8);
+        const type = String.fromCharCode(tar[offset + 156] ?? 0);
+        const prefix = field(offset + 345, 155);
+        const name = longName ?? (prefix ? `${prefix}/${field(offset, 100)}` : field(offset, 100));
+        const data = tar.subarray(offset + 512, offset + 512 + size);
+        longName = undefined;
+        if (type === 'L') {
+            longName = decoder.decode(data).replace(/\0+$/, '');
+        }
+        else if (type === 'x') {
+            longName = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(decoder.decode(data))?.[1];
+        }
+        else if (type === '0' || type === '\0') {
+            files.push({ name, data });
+        }
+        offset += 512 + Math.ceil(size / 512) * 512;
+    }
+    return files;
+}