@sema-agent/connectors 0.4.0 → 0.6.0

package/dist/release-archive.js

@@ -1,6 +1,16 @@
-import { gunzipSync } from 'node:zlib';
+import { chmodSync, closeSync, createReadStream, fchmodSync, fstatSync, mkdirSync, openSync, readSync, symlinkSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { createInflateRaw, gunzipSync, inflateRawSync } from 'node:zlib';
+import { writeAll, writeAllStream } from './write-all.js';
 const BLOCK = 512;
-const UNPACKED_LIMIT = 512 * 1024 * 1024;
+export const UNPACKED_LIMIT = 1024 * 1024 * 1024;
+const LINK_LIMIT = 4096;
+const FILE_MODE = 0o644;
+const EXEC_MODE = 0o755;
+const DIR_MODE = 0o755;
+export const formatOf = (file) => (/\.(?:tar\.gz|tgz)$/.test(file) ? 'tar.gz' : /\.zip$/.test(file) ? 'zip' : null);
 function text(h, at, length) {
     const raw = h.subarray(at, at + length);
     const end = raw.indexOf(0);
@@ -25,6 +35,8 @@ function pax(body) {
         const value = record.slice(eq + 1);
         if (key === 'path')
             out.path = value;
+        if (key === 'linkpath')
+            out.link = value;
         if (key === 'size') {
             if (!/^[0-9]+$/.test(value))
                 return null;
@@ -34,7 +46,7 @@ function pax(body) {
     }
     return out;
 }
-export function entryOf(archive, wanted) {
+function tarEntries(archive) {
     const refuse = (problem) => ({ ok: false, problem });
     let tar;
     try {
@@ -43,7 +55,7 @@ export function entryOf(archive, wanted) {
     catch {
         return refuse('is not a gzip stream within the size limit');
     }
-    const found = [];
+    const entries = [];
     let next = {};
     for (let at = 0;;) {
         if (at === tar.length)
@@ -59,7 +71,7 @@ export function entryOf(archive, wanted) {
         if (octal(h, 148, 8) !== sum)
             return refuse('has a damaged header');
         const type = h[156] === 0 ? '0' : String.fromCharCode(h[156] ?? 0);
-        const meta = type === 'x' || type === 'g' || type === 'L';
+        const meta = type === 'x' || type === 'g' || type === 'L' || type === 'K';
         const own = octal(h, 124, 12);
         const size = meta ? own : (next.size ?? own);
         if (size === null)
@@ -80,17 +92,457 @@ export function entryOf(archive, wanted) {
             next = { ...next, path: body.toString('utf8').replace(/\0+$/, '') };
             continue;
         }
+        if (type === 'K') {
+            next = { ...next, link: body.toString('utf8').replace(/\0+$/, '') };
+            continue;
+        }
         if (type === 'g')
             continue;
         const prefix = text(h, 257, 6).startsWith('ustar') ? text(h, 345, 155) : '';
         const name = next.path ?? (prefix === '' ? text(h, 0, 100) : `${prefix}/${text(h, 0, 100)}`);
+        const link = next.link ?? text(h, 157, 100);
         next = {};
-        if ((type === '0' || type === '7') && name.replace(/^\.\//, '') === wanted)
-            found.push(Buffer.from(body));
+        entries.push({ name, type: type === '7' ? '0' : type, mode: octal(h, 100, 8) ?? 0, body, link });
     }
+    return { ok: true, entries };
+}
+export function entryOf(archive, wanted) {
+    const read = tarEntries(archive);
+    if (!read.ok)
+        return read;
+    const found = read.entries.filter((e) => e.type === '0' && e.name.replace(/^\.\//, '') === wanted);
     if (found.length === 0)
-        return refuse(`holds no ${wanted}`);
+        return { ok: false, problem: `holds no ${wanted}` };
     if (found.length > 1)
-        return refuse(`holds ${wanted} more than once`);
-    return { ok: true, bytes: found[0] };
+        return { ok: false, problem: `holds ${wanted} more than once` };
+    return { ok: true, bytes: Buffer.from(found[0].body) };
+}
+const EOCD = 0x06054b50;
+const CENTRAL = 0x02014b50;
+const LOCAL = 0x04034b50;
+const ZIP64_LOCATOR = 0x07064b50;
+const UNIX = 3;
+const S_IFMT = 0o170000;
+function readAt(fd, position, length) {
+    const b = Buffer.alloc(length);
+    let got = 0;
+    while (got < length) {
+        const n = readSync(fd, b, got, length - got, position + got);
+        if (n === 0)
+            break;
+        got += n;
+    }
+    return got === length ? b : b.subarray(0, got);
+}
+function zipEntries(fd) {
+    const refuse = (problem) => ({ ok: false, problem });
+    const size = fstatSync(fd).size;
+    if (size < 22)
+        return refuse('is not a zip archive');
+    const tailStart = Math.max(0, size - 22 - 65535);
+    const tail = readAt(fd, tailStart, size - tailStart);
+    const ends = [];
+    for (let i = tail.length - 22; i >= 0; i--)
+        if (tail.readUInt32LE(i) === EOCD && i + 22 + tail.readUInt16LE(i + 20) === tail.length)
+            ends.push(i);
+    if (ends.length !== 1)
+        return refuse(ends.length === 0 ? 'is not a zip archive' : 'has more than one end record');
+    const e = ends[0];
+    const eocdAt = tailStart + e;
+    if (tail.readUInt16LE(e + 4) !== 0 || tail.readUInt16LE(e + 6) !== 0)
+        return refuse('is a split archive');
+    const count = tail.readUInt16LE(e + 10);
+    const cdSize = tail.readUInt32LE(e + 12);
+    const cdAt = tail.readUInt32LE(e + 16);
+    if (tail.readUInt16LE(e + 8) !== count || count === 0xffff || cdSize === 0xffffffff || cdAt === 0xffffffff)
+        return refuse('is a ZIP64 archive, which is not taken');
+    if (eocdAt >= 20 && readAt(fd, eocdAt - 20, 4).readUInt32LE(0) === ZIP64_LOCATOR)
+        return refuse('is a ZIP64 archive, which is not taken');
+    if (cdAt + cdSize !== eocdAt)
+        return refuse('has a central directory that does not end where its end record starts');
+    const cd = readAt(fd, cdAt, cdSize);
+    const entries = [];
+    const utf8 = new TextDecoder('utf-8', { fatal: true });
+    let total = 0;
+    let at = 0;
+    for (let i = 0; i < count; i++) {
+        if (at + 46 > cd.length || cd.readUInt32LE(at) !== CENTRAL)
+            return refuse('has a damaged central directory');
+        const host = cd.readUInt8(at + 5);
+        const flags = cd.readUInt16LE(at + 8);
+        const method = cd.readUInt16LE(at + 10);
+        const crc = cd.readUInt32LE(at + 16);
+        const compressed = cd.readUInt32LE(at + 20);
+        const unpacked = cd.readUInt32LE(at + 24);
+        const nameLength = cd.readUInt16LE(at + 28);
+        const extraLength = cd.readUInt16LE(at + 30);
+        const commentLength = cd.readUInt16LE(at + 32);
+        const disk = cd.readUInt16LE(at + 34);
+        const external = cd.readUInt32LE(at + 38);
+        const localAt = cd.readUInt32LE(at + 42);
+        const raw = cd.subarray(at + 46, at + 46 + nameLength);
+        at += 46 + nameLength + extraLength + commentLength;
+        if (at > cd.length)
+            return refuse('has a damaged central directory');
+        if (compressed === 0xffffffff || unpacked === 0xffffffff || localAt === 0xffffffff || disk !== 0)
+            return refuse('is a ZIP64 archive, which is not taken');
+        if ((flags & 0x0001) !== 0 || (flags & 0x0040) !== 0 || (flags & 0x2000) !== 0)
+            return refuse('holds an encrypted entry');
+        if (method !== 0 && method !== 8)
+            return refuse('holds an entry compressed with a method other than stored or deflate');
+        if (method === 0 && compressed !== unpacked)
+            return refuse('holds a stored entry whose sizes disagree');
+        if ((flags & 0x0800) === 0 && raw.some((b) => b >= 0x80))
+            return refuse('holds a name that is not flagged as UTF-8');
+        let name;
+        try {
+            name = utf8.decode(raw);
+        }
+        catch {
+            return refuse('holds a name that is not UTF-8');
+        }
+        const unixMode = host === UNIX ? external >>> 16 : 0;
+        const type = unixMode & S_IFMT;
+        const slash = name.endsWith('/');
+        let kind;
+        if (type === 0o120000)
+            kind = 'link';
+        else if (type === 0o040000 || (type === 0 && slash))
+            kind = 'directory';
+        else if (type === 0o100000 || type === 0)
+            kind = 'file';
+        else
+            return refuse('holds an entry of a kind that is not taken (a device, a pipe or a socket)');
+        if ((kind === 'directory') !== slash)
+            return refuse('holds an entry whose kind and name disagree');
+        if (kind === 'link' && unpacked > LINK_LIMIT)
+            return refuse('holds a symbolic link with a target that is too long');
+        total += unpacked;
+        if (total > UNPACKED_LIMIT)
+            return refuse(`unpacks to more than ${UNPACKED_LIMIT} bytes`);
+        const local = readAt(fd, localAt, 30);
+        if (local.length !== 30 || local.readUInt32LE(0) !== LOCAL)
+            return refuse('has a damaged local header');
+        const localName = readAt(fd, localAt + 30, local.readUInt16LE(26));
+        if (!localName.equals(raw) || local.readUInt16LE(8) !== method || (local.readUInt16LE(6) & 0x0001) !== 0)
+            return refuse('has a local header that disagrees with its central directory');
+        const data = localAt + 30 + local.readUInt16LE(26) + local.readUInt16LE(28);
+        entries.push({ name, kind, mode: unixMode & 0o7777, method, crc, compressed, size: unpacked, local: localAt, data });
+    }
+    if (at !== cd.length)
+        return refuse('has a damaged central directory');
+    const byPlace = [...entries].sort((a, b) => a.local - b.local);
+    for (let i = 0; i < byPlace.length; i++) {
+        const x = byPlace[i];
+        const limit = i + 1 < byPlace.length ? byPlace[i + 1].local : cdAt;
+        if (x.local === limit || x.data + x.compressed > limit)
+            return refuse('holds entries whose data overlap');
+    }
+    return { ok: true, entries };
+}
+const CRC_TABLE = (() => {
+    const t = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c;
+    }
+    return t;
+})();
+function crc32(crc, bytes) {
+    let c = ~crc;
+    for (let i = 0; i < bytes.length; i++)
+        c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    return ~c >>> 0;
+}
+function zipBytes(fd, e) {
+    const packed = readAt(fd, e.data, e.compressed);
+    if (packed.length !== e.compressed)
+        return null;
+    let bytes;
+    try {
+        bytes = e.method === 8 ? inflateRawSync(packed, { maxOutputLength: Math.max(e.size, 1) }) : packed;
+    }
+    catch {
+        return null;
+    }
+    return bytes.length === e.size && crc32(0, bytes) === e.crc ? bytes : null;
+}
+function withFile(path, fn) {
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return null;
+    }
+    try {
+        return { value: fn(fd) };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+const wholeFile = (path) => withFile(path, (fd) => readAt(fd, 0, fstatSync(fd).size))?.value ?? null;
+export function archiveEntry(path, format, wanted) {
+    if (format === 'tar.gz') {
+        const bytes = wholeFile(path);
+        return bytes === null ? { ok: false, problem: 'cannot be read' } : entryOf(bytes, wanted);
+    }
+    const r = withFile(path, (fd) => {
+        const read = zipEntries(fd);
+        if (!read.ok)
+            return read;
+        const found = read.entries.filter((e) => e.kind === 'file' && e.name === wanted);
+        if (found.length === 0)
+            return { ok: false, problem: `holds no ${wanted}` };
+        if (found.length > 1)
+            return { ok: false, problem: `holds ${wanted} more than once` };
+        const bytes = zipBytes(fd, found[0]);
+        return bytes === null ? { ok: false, problem: `holds a damaged ${wanted}` } : { ok: true, bytes };
+    });
+    return r?.value ?? { ok: false, problem: 'cannot be read' };
+}
+const SEGMENT_BAD = /[\x00-\x1f\x7f\\]/;
+const segmentProblem = (s) => s === '' || s === '.' || SEGMENT_BAD.test(s);
+function below(name, top) {
+    const bare = name.replace(/^\.\//, '');
+    if (bare.startsWith('/'))
+        return { problem: 'holds an entry with an absolute path' };
+    if (bare === top || bare === `${top}/`)
+        return { segments: [] };
+    if (!bare.startsWith(`${top}/`))
+        return { problem: `holds an entry outside ${top}/` };
+    const rest = bare.slice(top.length + 1).replace(/\/$/, '');
+    const segments = rest.split('/');
+    if (segments.some((s) => s === '..'))
+        return { problem: 'holds an entry whose path climbs out of its directory (..)' };
+    if (segments.some(segmentProblem))
+        return { problem: 'holds an entry whose path has an empty or "." segment, a backslash or a control character' };
+    return { segments };
+}
+const linkTargetTaken = (target) => target !== '' && !target.startsWith('/') && target.split('/').every((s) => s !== '..' && !segmentProblem(s));
+function plannedProblem(planned) {
+    const kinds = new Map();
+    for (const p of planned) {
+        const key = p.segments.join('/');
+        if (kinds.has(key))
+            return 'holds a name more than once';
+        kinds.set(key, p.kind);
+    }
+    for (const p of planned) {
+        for (let i = 1; i < p.segments.length; i++) {
+            const parent = kinds.get(p.segments.slice(0, i).join('/'));
+            if (parent !== undefined && parent !== 'directory')
+                return `holds an entry below a ${parent === 'link' ? 'symbolic link' : 'file'} of the archive`;
+        }
+    }
+    return null;
+}
+async function writePlanned(planned, dest) {
+    const pathOf = (p) => join(dest, ...p.segments);
+    const directory = (path) => {
+        mkdirSync(path, { recursive: true, mode: DIR_MODE });
+        chmodSync(path, DIR_MODE);
+    };
+    for (const p of planned)
+        if (p.kind === 'directory')
+            directory(pathOf(p));
+    for (const p of planned) {
+        if (p.kind !== 'file')
+            continue;
+        mkdirSync(dirname(pathOf(p)), { recursive: true, mode: DIR_MODE });
+        const problem = await p.write(pathOf(p));
+        if (problem !== null)
+            return problem;
+    }
+    for (const p of planned) {
+        if (p.kind !== 'link')
+            continue;
+        mkdirSync(dirname(pathOf(p)), { recursive: true, mode: DIR_MODE });
+        symlinkSync(p.link, pathOf(p));
+    }
+    return null;
+}
+const modeOf = (mode) => ((mode & 0o111) !== 0 ? EXEC_MODE : FILE_MODE);
+function writeBytes(target, bytes, mode) {
+    const fd = openSync(target, 'wx', mode);
+    try {
+        fchmodSync(fd, mode);
+        writeAll(fd, bytes);
+    }
+    finally {
+        closeSync(fd);
+    }
+    return null;
+}
+function planTar(archive, top) {
+    const read = tarEntries(archive);
+    if (!read.ok)
+        return { problem: read.problem };
+    const planned = [];
+    for (const e of read.entries) {
+        const where = below(e.name, top);
+        if ('problem' in where)
+            return where;
+        if (where.segments.length === 0)
+            continue;
+        if (e.type === '0') {
+            const mode = modeOf(e.mode);
+            planned.push({ segments: where.segments, kind: 'file', mode, size: e.body.length, write: (target) => writeBytes(target, e.body, mode) });
+        }
+        else if (e.type === '5')
+            planned.push({ segments: where.segments, kind: 'directory', mode: DIR_MODE, size: 0, write: () => null });
+        else if (e.type === '2') {
+            if (!linkTargetTaken(e.link))
+                return { problem: 'holds a symbolic link whose target is not a relative path below its own directory' };
+            planned.push({ segments: where.segments, kind: 'link', mode: 0, size: 0, link: e.link, write: () => null });
+        }
+        else if (e.type === '1')
+            return { problem: 'holds a hard link, which is not taken' };
+        else
+            return { problem: 'holds an entry of a kind that is not taken (a device, a pipe or a socket)' };
+    }
+    return { planned };
+}
+class Checked extends Transform {
+    limit;
+    size = 0;
+    crc = 0;
+    constructor(limit) {
+        super();
+        this.limit = limit;
+    }
+    _transform(chunk, _encoding, done) {
+        this.size += chunk.length;
+        if (this.size > this.limit)
+            return done(new Error('the entry is larger than the archive says'));
+        this.crc = crc32(this.crc, chunk);
+        done(null, chunk);
+    }
+}
+function planZip(fd, path, top) {
+    const read = zipEntries(fd);
+    if (!read.ok)
+        return { problem: read.problem };
+    const planned = [];
+    for (const e of read.entries) {
+        const where = below(e.name, top);
+        if ('problem' in where)
+            return where;
+        if (where.segments.length === 0)
+            continue;
+        if (e.kind === 'directory')
+            planned.push({ segments: where.segments, kind: 'directory', mode: DIR_MODE, size: 0, write: () => null });
+        else if (e.kind === 'link') {
+            const target = zipBytes(fd, e);
+            if (target === null)
+                return { problem: 'holds a damaged symbolic link' };
+            const link = target.toString('utf8');
+            if (!linkTargetTaken(link))
+                return { problem: 'holds a symbolic link whose target is not a relative path below its own directory' };
+            planned.push({ segments: where.segments, kind: 'link', mode: 0, size: 0, link, write: () => null });
+        }
+        else {
+            const mode = modeOf(e.mode);
+            planned.push({
+                segments: where.segments,
+                kind: 'file',
+                mode,
+                size: e.size,
+                write: async (target) => {
+                    if (e.compressed === 0)
+                        return e.size === 0 && e.crc === 0 ? writeBytes(target, Buffer.alloc(0), mode) : 'holds a damaged entry';
+                    const checked = new Checked(e.size);
+                    const source = createReadStream(path, { start: e.data, end: e.data + e.compressed - 1 });
+                    let fd = null;
+                    try {
+                        fd = openSync(target, 'wx', mode);
+                        fchmodSync(fd, mode);
+                        if (e.method === 8)
+                            await pipeline(source, createInflateRaw(), checked, writeAllStream(fd));
+                        else
+                            await pipeline(source, checked, writeAllStream(fd));
+                    }
+                    catch {
+                        source.destroy();
+                        return 'holds a damaged entry';
+                    }
+                    finally {
+                        if (fd !== null)
+                            closeSync(fd);
+                    }
+                    return checked.size === e.size && checked.crc === e.crc ? null : 'holds an entry whose size or CRC-32 does not match the archive';
+                },
+            });
+        }
+    }
+    return { planned };
+}
+export async function unpackTree(path, format, top, dest) {
+    if (format === 'tar.gz') {
+        const bytes = wholeFile(path);
+        if (bytes === null)
+            return 'cannot be read';
+        const plan = planTar(bytes, top);
+        if ('problem' in plan)
+            return plan.problem;
+        return plannedProblem(plan.planned) ?? (await writePlanned(plan.planned, dest));
+    }
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return 'cannot be read';
+    }
+    try {
+        const plan = planZip(fd, path, top);
+        if ('problem' in plan)
+            return plan.problem;
+        return plannedProblem(plan.planned) ?? (await writePlanned(plan.planned, dest));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function treeProblem(path, format, top) {
+    if (format === 'tar.gz') {
+        const bytes = wholeFile(path);
+        if (bytes === null)
+            return 'cannot be read';
+        const plan = planTar(bytes, top);
+        return 'problem' in plan ? plan.problem : plannedProblem(plan.planned);
+    }
+    const r = withFile(path, (fd) => {
+        const plan = planZip(fd, path, top);
+        return 'problem' in plan ? plan.problem : plannedProblem(plan.planned);
+    });
+    return r === null ? 'cannot be read' : r.value;
+}
+export function treeListing(path, format, top) {
+    const listed = (plan) => {
+        if ('problem' in plan)
+            return { ok: false, problem: plan.problem };
+        const problem = plannedProblem(plan.planned);
+        if (problem !== null)
+            return { ok: false, problem };
+        const paths = new Map();
+        for (const p of plan.planned) {
+            for (let i = 1; i < p.segments.length; i++) {
+                const parent = p.segments.slice(0, i).join('/');
+                if (!paths.has(parent))
+                    paths.set(parent, { kind: 'directory', mode: DIR_MODE, size: 0 });
+            }
+            paths.set(p.segments.join('/'), { kind: p.kind, mode: p.kind === 'link' ? 0 : p.mode, size: p.size, ...(p.link !== undefined ? { link: p.link } : {}) });
+        }
+        return { ok: true, paths };
+    };
+    if (format === 'tar.gz') {
+        const bytes = wholeFile(path);
+        return bytes === null ? { ok: false, problem: 'cannot be read' } : listed(planTar(bytes, top));
+    }
+    const r = withFile(path, (fd) => listed(planZip(fd, path, top)));
+    return r === null ? { ok: false, problem: 'cannot be read' } : r.value;
 }

package/dist/secrets.d.ts

@@ -20,6 +20,7 @@ export interface FileSecrets {
     readonly directory: string;
     list(): SecretListing;
     put(name: string, value: string, options?: PutOptions): SecretHandle;
+    remove(name: string): boolean;
     withLock<T>(fn: () => T): T;
 }
 export declare const isSecret: (handle: SecretHandle) => boolean;

package/dist/secrets.js

@@ -232,6 +232,8 @@ function putHandle(dir, connector, name, value, options) {
         throw new Error('a handle name is upper-case letters, digits and underscores, starting with a letter');
     if (typeof value !== 'string')
         throw new Error('a secret value is a string');
+    if (value === '')
+        throw new TypeError('a secret value is never the empty string (use remove to take the handle away)');
     if (options.expiresAt !== undefined && !validExpiry(options.expiresAt))
         throw new Error('expiresAt must be an RFC 3339 UTC time ending in Z');
     if (options.secret !== undefined && typeof options.secret !== 'boolean')
@@ -242,6 +244,37 @@ function putHandle(dir, connector, name, value, options) {
         throw new Error(r.problem);
     return r.value;
 }
+function removeHandle(dir, connector, name) {
+    if (!HANDLE_NAME.test(name))
+        throw new Error('a handle name is upper-case letters, digits and underscores, starting with a letter');
+    try {
+        lstatSync(dir);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return false;
+        throw new Error(`connector ${connector}: the secrets directory cannot be read`);
+    }
+    const dirProblem = entryProblem(dir, 'directory', 'the secrets directory');
+    if (dirProblem !== null)
+        throw new Error(`connector ${connector}: ${dirProblem}`);
+    const r = locked(dir, connector, () => {
+        let existed = true;
+        try {
+            rmSync(join(dir, name));
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+            existed = false;
+        }
+        rmSync(join(dir, name + META_SUFFIX), { force: true });
+        return existed;
+    });
+    if (!r.ok)
+        throw new Error(r.problem);
+    return r.value;
+}
 export function openFileSecrets(options) {
     if (typeof options?.configDir !== 'string' || !isAbsolute(options.configDir))
         throw new Error('configDir must be an absolute path');
@@ -253,6 +286,7 @@ export function openFileSecrets(options) {
         directory: dir,
         list: () => listHandles(dir, connector),
         put: (name, value, putOptions = {}) => putHandle(dir, connector, name, value, putOptions),
+        remove: (name) => removeHandle(dir, connector, name),
         withLock: (fn) => {
             ensureDirectory(dir, connector);
             const r = locked(dir, connector, fn);

package/dist/session.js

@@ -118,7 +118,7 @@ export class Session {
         switch (m.method) {
             case 'tools/call': {
                 if (typeof name !== 'string' || !isGranted(grant, name))
-                    return [up(errorLine(id, INVALID_PARAMS, 'the requested tool is not in the granted scope', FORBIDDEN_SCOPE)), ...this.settle(call, 'refused', FORBIDDEN_SCOPE)];
+                    return id === null ? [] : [up(errorLine(id, INVALID_PARAMS, 'the requested tool is not in the granted scope', FORBIDDEN_SCOPE)), ...this.settle(call, 'refused', FORBIDDEN_SCOPE)];
                 if (this.options.parked === true)
                     return id === null ? [] : [up(errorLine(id, INTERNAL_ERROR, noCredentials(this.options.connector), AUTH_REQUIRED)), ...this.settle(call, 'refused', AUTH_REQUIRED)];
                 return this.forward(raw, id, grant, undefined, undefined, call);

package/dist/write-all.d.ts

@@ -1,2 +1,4 @@
+import { Writable } from 'node:stream';
 export declare function writeAll(fd: number, data: string | Uint8Array): void;
+export declare function writeAllStream(fd: number): Writable;
 export declare function writeFailure(e: unknown): string;

package/dist/write-all.js

@@ -1,17 +1,47 @@
 import { fstatSync, fsyncSync, writeSync } from 'node:fs';
-export function writeAll(fd, data) {
-    const bytes = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+import { Writable } from 'node:stream';
+function writeAllAt(fd, bytes, position) {
     let written = 0;
     while (written < bytes.length) {
-        const n = writeSync(fd, bytes, written, bytes.length - written, written);
+        const n = writeSync(fd, bytes, written, bytes.length - written, position + written);
         if (n <= 0)
             throw new Error(`a write stopped after ${written} of ${bytes.length} bytes`);
         written += n;
     }
+    return position + written;
+}
+function finished(fd, size) {
     fsyncSync(fd);
-    const size = fstatSync(fd).size;
-    if (size !== bytes.length)
-        throw new Error(`the file holds ${size} bytes after a write of ${bytes.length}`);
+    const held = fstatSync(fd).size;
+    if (held !== size)
+        throw new Error(`the file holds ${held} bytes after a write of ${size}`);
+}
+export function writeAll(fd, data) {
+    const bytes = typeof data === 'string' ? Buffer.from(data, 'utf8') : data;
+    finished(fd, writeAllAt(fd, bytes, 0));
+}
+export function writeAllStream(fd) {
+    let position = 0;
+    return new Writable({
+        write(piece, _encoding, done) {
+            try {
+                position = writeAllAt(fd, piece, position);
+                done();
+            }
+            catch (e) {
+                done(e);
+            }
+        },
+        final(done) {
+            try {
+                finished(fd, position);
+                done();
+            }
+            catch (e) {
+                done(e);
+            }
+        },
+    });
 }
 export function writeFailure(e) {
     const code = e?.code;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/connectors",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Shared connector layer and the sema-connector launcher (MCP stdio proxy with principal, scope, normalize, status and trace stages).",
   "license": "Apache-2.0",
   "type": "module",