sliccy 6.154.1 → 6.154.3

package/dist/node-server/hostfs.d.ts

@@ -56,7 +56,8 @@
  * otherwise express's default handler answers malformed JSON with code-less
  * HTML and the webapp cannot rethrow a faithful `FsError`.
  */
-import type { Express } from 'express';
+import type { ErrorRequestHandler, Express, Response } from 'express';
+import { createReadStream } from 'fs';
 import type { HostMountMapping } from './runtime-flags.js';
 /**
  * Cap on a WHOLE-FILE `GET /api/hostfs/read` (and on `PUT /write`). It exists
@@ -68,6 +69,14 @@ import type { HostMountMapping } from './runtime-flags.js';
  * Matches the webapp's hostfs body cap (backend-hostfs.ts).
  */
 export declare const HOSTFS_MAX_BODY_BYTES: number;
+interface FsCodeError {
+    status: number;
+    code: string;
+    message: string;
+}
+/** Map an fs errno (or traversal rejection) to an HTTP status + FsError code. */
+export declare function toFsCodeError(err: unknown): FsCodeError;
+export declare function sendFsError(res: Response, err: unknown): void;
 /**
  * Resolve `relPath` against `root`, rejecting anything that leaves the root
  * either lexically (`..`) or via symlinks. Symlinks *inside* the root that
@@ -114,6 +123,22 @@ export type ParsedByteRange = {
  * A zero-length file has no satisfiable range at all.
  */
 export declare function parseByteRange(header: string | undefined, size: number): ParsedByteRange;
+/**
+ * Stream a file (or a window of it) to the response instead of buffering it.
+ *
+ * `readFile` + `res.send` held the whole body in the server process — 92 MB
+ * per pack read in the benchmark of issue #2707 — for no benefit: express is
+ * already writing to a socket. Headers are committed on the stream's `open`,
+ * so a failure to open (a raced unlink, EACCES) still rejects BEFORE anything
+ * is on the wire and is mapped to the usual errno JSON by the caller. After
+ * that point the status line is spent, so a mid-body failure can only be
+ * reported by destroying the connection — a truncated body the client's
+ * `fetch` rejects on, which its retry path already handles.
+ */
+export declare function streamFileBody(res: Response, target: string, status: number, headers: Record<string, string>, window?: {
+    start: number;
+    end: number;
+}, createStream?: typeof createReadStream): Promise<void>;
 /**
  * Resolve the configured mappings to realpath'd roots. Mappings whose OS
  * path does not exist (or is not a directory) are dropped with a warning —
@@ -139,6 +164,16 @@ export declare function isHostFsStableBodyRequest(req: {
     method?: string;
     url?: string;
 }): boolean;
+/**
+ * Map body-parser failures on the hostfs surface to `{ code, message }`.
+ * Registered after the routes (express only runs an error handler for
+ * middleware mounted before it), so it catches the stable dispatcher's JSON
+ * parser AND `PUT /write`'s raw parser. Mirrors swift-server, which answers
+ * 400 `EINVAL` for an unparseable body and 413 `EFBIG` for an oversized one.
+ * Anything that is not a body-parser error, and every non-hostfs path, is
+ * passed through untouched.
+ */
+export declare const hostFsBodyErrorHandler: ErrorRequestHandler;
 /**
  * Register the /api/hostfs routes for the resolved mount roots. The route
  * surface mirrors `MountBackend` 1:1 (webapp `backend-hostfs.ts`):
@@ -167,3 +202,4 @@ export declare function isHostFsStableBodyRequest(req: {
  * per-op routes — so every error this route emits MUST carry a `code`.
  */
 export declare function registerHostFsRoutes(app: Express, roots: readonly HostMountRoot[]): void;
+export {};

package/dist/node-server/hostfs.js

@@ -75,7 +75,7 @@ function errnoCode(err) {
     return typeof code === 'string' ? code : null;
 }
 /** Map an fs errno (or traversal rejection) to an HTTP status + FsError code. */
-function toFsCodeError(err) {
+export function toFsCodeError(err) {
     const code = errnoCode(err) ?? 'EIO';
     const message = err instanceof Error ? err.message : String(err);
     switch (code) {
@@ -93,7 +93,7 @@ function toFsCodeError(err) {
             return { status: 500, code, message };
     }
 }
-function sendFsError(res, err) {
+export function sendFsError(res, err) {
     // A streamed body may already have committed the status line; the only
     // honest signal left is a broken connection.
     if (res.headersSent) {
@@ -200,8 +200,8 @@ export function parseByteRange(header, size) {
  * reported by destroying the connection — a truncated body the client's
  * `fetch` rejects on, which its retry path already handles.
  */
-async function streamFileBody(res, target, status, headers, window) {
-    const stream = createReadStream(target, window);
+export async function streamFileBody(res, target, status, headers, window, createStream = createReadStream) {
+    const stream = createStream(target, window);
     await new Promise((resolveStream, rejectStream) => {
         let committed = false;
         stream.once('open', () => {
@@ -382,7 +382,7 @@ export function isHostFsStableBodyRequest(req) {
  * Anything that is not a body-parser error, and every non-hostfs path, is
  * passed through untouched.
  */
-const hostFsBodyErrorHandler = (err, req, res, next) => {
+export const hostFsBodyErrorHandler = (err, req, res, next) => {
     const type = err?.type;
     if (typeof type !== 'string' || res.headersSent || !isHostFsPath(req.path)) {
         next(err);

package/dist/node-server/install-cli.d.ts

@@ -4,6 +4,7 @@ export interface ResolvedCliAsset {
     downloadUrl: string;
 }
 export declare function cliAssetName(platform: string, arch: string): string | null;
+export declare function defaultIsWritableDir(dir: string): boolean;
 /**
  * OS-idiomatic install dir, in preference order:
  *

package/dist/node-server/install-cli.js

@@ -30,7 +30,7 @@ export function cliAssetName(platform, arch) {
     }
     return `slicc-${os}-${goArch}${os === 'windows' ? '.exe' : ''}`;
 }
-function defaultIsWritableDir(dir) {
+export function defaultIsWritableDir(dir) {
     try {
         accessSync(dir, constants.W_OK);
         return true;

package/dist/node-server/launch-url.js

@@ -15,12 +15,8 @@ function buildTrayJoinLaunchUrl(locationHref, joinUrl) {
     }
     return buildCanonicalTrayLaunchUrl(locationHref, parsedJoinUrl.joinUrl);
 }
-function buildTrayLeadLaunchUrl(locationHref, workerBaseUrl) {
-    const normalizedBase = normalizeTrayWorkerBaseUrl(workerBaseUrl);
-    if (!normalizedBase) {
-        throw new Error(`Invalid tray worker base URL: ${workerBaseUrl}`);
-    }
-    return buildCanonicalTrayLaunchUrl(locationHref, normalizedBase);
+function buildTrayLeadLaunchUrl(locationHref, normalizedWorkerBaseUrl) {
+    return buildCanonicalTrayLaunchUrl(locationHref, normalizedWorkerBaseUrl);
 }
 export function resolveCliBrowserLaunchUrl(options) {
     if (options.lead && options.join) {

package/dist/node-server/leader-restart.d.ts

@@ -1,4 +1,5 @@
 import type { Express } from 'express';
+import { WebSocket } from 'ws';
 export interface CdpTargetInfo {
     id?: string;
     targetId?: string;
@@ -18,6 +19,14 @@ export type RestartResult = {
     message: string;
 };
 export declare function restartLeader(cdp: CdpLike, pageUrlPrefix: string): Promise<RestartResult>;
+export declare class CdpClient {
+    private readonly socket;
+    private nextId;
+    private readonly pending;
+    constructor(socket: WebSocket);
+    send(method: string, params?: unknown, sessionId?: string): Promise<unknown>;
+    close(): void;
+}
 /**
  * HTTP-backed CdpLike. Implements Target.getTargets via the CDP HTTP /json
  * endpoint. Target.attachToTarget + Page.reload are sent over WebSocket.

package/dist/node-server/leader-restart.js

@@ -41,7 +41,7 @@ export async function restartLeader(cdp, pageUrlPrefix) {
         return { ok: false, code: 'INTERNAL', message: String(err) };
     }
 }
-class CdpClient {
+export class CdpClient {
     socket;
     nextId = 1;
     pending = new Map();

package/dist/node-server/publish-chrome-web-store-main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node-server/publish-chrome-web-store-main.js

@@ -0,0 +1,13 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { publishChromeWebStoreRelease } from './publish-chrome-web-store.js';
+const dirname = fileURLToPath(new URL('.', import.meta.url));
+const projectRoot = resolve(dirname, '..', '..');
+const manifestPath = process.argv[2]
+    ? resolve(projectRoot, process.argv[2])
+    : resolve(projectRoot, 'artifacts', 'release', 'release-artifacts.json');
+void publishChromeWebStoreRelease({ manifestPath }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[publish-chrome-web-store] ${message}`);
+    process.exit(1);
+});

package/dist/node-server/publish-chrome-web-store.d.ts

@@ -46,6 +46,8 @@ export interface PublishChromeWebStoreOptions {
 export declare function parseServiceAccountCredentials(jsonValue: string | undefined, base64Value: string | undefined): ServiceAccountCredentials | undefined;
 export declare function readChromeWebStoreConfig(env?: NodeJS.ProcessEnv): ChromeWebStoreConfig | null;
 export declare function createServiceAccountAssertion(serviceAccount: ServiceAccountCredentials, nowSeconds: number): string;
+export declare function cancelPendingSubmission(config: ChromeWebStoreConfig, accessToken: string, fetchImpl: typeof fetch): Promise<void>;
+export declare function waitForPendingReviewCancellation(config: ChromeWebStoreConfig, accessToken: string, fetchImpl: typeof fetch, waitMs: (ms: number) => Promise<void>, pollIntervalMs: number, maxAttempts: number): Promise<FetchStatusResponse>;
 export declare function waitForUploadCompletion(config: ChromeWebStoreConfig, accessToken: string, fetchImpl: typeof fetch, waitMs: (ms: number) => Promise<void>, pollIntervalMs: number, maxAttempts: number): Promise<FetchStatusResponse>;
 export declare function publishChromeWebStoreRelease(options?: PublishChromeWebStoreOptions): Promise<ChromeWebStorePublishResult | null>;
 export {};

package/dist/node-server/publish-chrome-web-store.js

@@ -201,7 +201,7 @@ async function fetchUploadStatus(config, accessToken, fetchImpl) {
     });
     return expectJsonResponse(response, 'Chrome Web Store upload status');
 }
-async function cancelPendingSubmission(config, accessToken, fetchImpl) {
+export async function cancelPendingSubmission(config, accessToken, fetchImpl) {
     const itemName = createPublisherItemName(config);
     const response = await fetchImpl(`https://chromewebstore.googleapis.com/v2/${itemName}:cancelSubmission`, {
         method: 'POST',
@@ -214,7 +214,7 @@ async function cancelPendingSubmission(config, accessToken, fetchImpl) {
         throw new Error(`Chrome Web Store cancel submission failed with ${response.status} ${response.statusText}.${text ? ` ${text}` : ''}`);
     }
 }
-async function waitForPendingReviewCancellation(config, accessToken, fetchImpl, waitMs, pollIntervalMs, maxAttempts) {
+export async function waitForPendingReviewCancellation(config, accessToken, fetchImpl, waitMs, pollIntervalMs, maxAttempts) {
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const status = await fetchUploadStatus(config, accessToken, fetchImpl);
         if (status.submittedItemRevisionStatus?.state !== 'PENDING_REVIEW') {
@@ -358,16 +358,3 @@ export async function publishChromeWebStoreRelease(options = {}) {
         publishState: publishResponse.state,
     };
 }
-async function main() {
-    const manifestPath = process.argv[2]
-        ? resolve(PROJECT_ROOT, process.argv[2])
-        : DEFAULT_RELEASE_MANIFEST_PATH;
-    await publishChromeWebStoreRelease({ manifestPath });
-}
-if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
-    void main().catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[publish-chrome-web-store] ${message}`);
-        process.exit(1);
-    });
-}

package/dist/node-server/release-package-main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node-server/release-package-main.js

@@ -0,0 +1,17 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { packageReleaseArtifacts, toProjectRelative } from './release-package.js';
+const dirname = fileURLToPath(new URL('.', import.meta.url));
+const projectRoot = resolve(dirname, '..', '..');
+const releaseDir = resolve(projectRoot, 'artifacts', 'release');
+try {
+    const manifest = packageReleaseArtifacts({ projectRoot, releaseDir });
+    console.log(`Created extension archive: ${manifest.extensionArchive}`);
+    console.log(`Created npm package tarball: ${manifest.npmPackageTarball}`);
+    console.log(`Created release manifest: ${toProjectRelative(projectRoot, resolve(releaseDir, 'release-artifacts.json'))}`);
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[package:release] ${message}`);
+    process.exit(1);
+}

package/dist/node-server/release-package.d.ts

@@ -1,16 +1,51 @@
-interface ZipEntry {
+export interface PackageMetadata {
+    name: string;
+    version: string;
+}
+export interface ZipEntry {
     path: string;
     data: Buffer;
     mode: number;
 }
-interface ReleaseManifest {
+export interface ReleaseManifest {
     version: string;
     extensionArchive: string;
     npmPackageTarball: string;
 }
+export declare function comparePaths(left: string, right: string): number;
 export declare function sanitizeArtifactName(value: string): string;
 export declare function collectZipEntries(rootDir: string): ZipEntry[];
 export declare function createDeterministicZip(entries: readonly ZipEntry[]): Buffer;
+export declare function requirePath(path: string, description: string): void;
+export declare function toProjectRelative(projectRoot: string, path: string): string;
+export declare function resolveNpmCommand(options?: {
+    npmExecPath?: string;
+    execPath?: string;
+    platform?: NodeJS.Platform;
+}): {
+    command: string;
+    argsPrefix: string[];
+};
 export declare function parseNpmPackFilename(output: string): string;
-export declare function packageReleaseArtifacts(): ReleaseManifest;
+export declare function createExtensionArchive(metadata: PackageMetadata, projectRoot: string, releaseDir: string): string;
+interface NpmPackResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+export declare function createNpmPackageTarball(options: {
+    projectRoot: string;
+    releaseDir: string;
+    npm?: {
+        command: string;
+        argsPrefix: string[];
+    };
+    spawn?: (command: string, args: string[], options: object) => NpmPackResult;
+}): string;
+export declare function writeReleaseManifest(manifest: ReleaseManifest, releaseDir: string): string;
+export declare function packageReleaseArtifacts(options: {
+    projectRoot: string;
+    releaseDir?: string;
+    spawn?: (command: string, args: string[], options: object) => NpmPackResult;
+}): ReleaseManifest;
 export {};

package/dist/node-server/release-package.js

@@ -1,18 +1,14 @@
 import { spawnSync } from 'child_process';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'fs';
 import { join, relative, resolve } from 'path';
-import { fileURLToPath } from 'url';
 import { deflateRawSync } from 'zlib';
-const Dirname = fileURLToPath(new URL('.', import.meta.url));
-const PROJECT_ROOT = resolve(Dirname, '..', '..');
-const RELEASE_DIR = resolve(PROJECT_ROOT, 'artifacts', 'release');
 const FIXED_ZIP_DATE = new Date(Date.UTC(1980, 0, 1, 0, 0, 0));
 const ZIP_VERSION = 20;
 const ZIP_UTF8_FLAG = 0x0800;
 const ZIP_METHOD_DEFLATE = 8;
 const ZIP_FILE_MODE = 0o100644;
 const CRC32_TABLE = buildCrc32Table();
-function comparePaths(left, right) {
+export function comparePaths(left, right) {
     if (left < right)
         return -1;
     if (left > right)
@@ -138,21 +134,21 @@ function encodeDosDateTime(value) {
 function readJsonFile(path) {
     return JSON.parse(readFileSync(path, 'utf8'));
 }
-function requirePath(path, description) {
+export function requirePath(path, description) {
     if (!existsSync(path)) {
         throw new Error(`${description} was not found at ${path}. Run the required build command(s) first.`);
     }
 }
-function toProjectRelative(path) {
-    return relative(PROJECT_ROOT, path).split('\\').join('/');
+export function toProjectRelative(projectRoot, path) {
+    return relative(projectRoot, path).split('\\').join('/');
 }
-function resolveNpmCommand() {
-    const npmExecPath = process.env['npm_execpath'];
+export function resolveNpmCommand(options = {}) {
+    const npmExecPath = options.npmExecPath ?? process.env['npm_execpath'];
     if (npmExecPath) {
-        return { command: process.execPath, argsPrefix: [npmExecPath] };
+        return { command: options.execPath ?? process.execPath, argsPrefix: [npmExecPath] };
     }
     return {
-        command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+        command: (options.platform ?? process.platform) === 'win32' ? 'npm.cmd' : 'npm',
         argsPrefix: [],
     };
 }
@@ -164,60 +160,60 @@ export function parseNpmPackFilename(output) {
     }
     return filename;
 }
-function createExtensionArchive(metadata) {
-    const extensionDir = resolve(PROJECT_ROOT, 'dist', 'extension');
+export function createExtensionArchive(metadata, projectRoot, releaseDir) {
+    const extensionDir = resolve(projectRoot, 'dist', 'extension');
     requirePath(extensionDir, 'Extension build output');
-    const zipPath = resolve(RELEASE_DIR, `${sanitizeArtifactName(metadata.name)}-extension-v${metadata.version}.zip`);
+    const zipPath = resolve(releaseDir, `${sanitizeArtifactName(metadata.name)}-extension-v${metadata.version}.zip`);
     const zipBuffer = createDeterministicZip(collectZipEntries(extensionDir));
     writeFileSync(zipPath, zipBuffer);
     return zipPath;
 }
-function createNpmPackageTarball() {
-    requirePath(resolve(PROJECT_ROOT, 'dist', 'node-server'), 'CLI build output');
-    requirePath(resolve(PROJECT_ROOT, 'dist', 'ui'), 'UI build output');
-    const npm = resolveNpmCommand();
-    const result = spawnSync(npm.command, [...npm.argsPrefix, 'pack', '--json', '--ignore-scripts', '--pack-destination', RELEASE_DIR], {
-        cwd: PROJECT_ROOT,
+export function createNpmPackageTarball(options) {
+    requirePath(resolve(options.projectRoot, 'dist', 'node-server'), 'CLI build output');
+    requirePath(resolve(options.projectRoot, 'dist', 'ui'), 'UI build output');
+    const npm = options.npm ?? resolveNpmCommand();
+    const args = [
+        ...npm.argsPrefix,
+        'pack',
+        '--json',
+        '--ignore-scripts',
+        '--pack-destination',
+        options.releaseDir,
+    ];
+    const spawnOptions = {
+        cwd: options.projectRoot,
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    };
+    const result = options.spawn
+        ? options.spawn(npm.command, args, spawnOptions)
+        : spawnSync(npm.command, args, spawnOptions);
     if (result.status !== 0) {
         throw new Error((result.stderr || result.stdout || 'npm pack failed').trim());
     }
-    return resolve(RELEASE_DIR, parseNpmPackFilename(result.stdout));
+    return resolve(options.releaseDir, parseNpmPackFilename(result.stdout));
 }
-function writeReleaseManifest(manifest) {
-    const manifestPath = resolve(RELEASE_DIR, 'release-artifacts.json');
+export function writeReleaseManifest(manifest, releaseDir) {
+    const manifestPath = resolve(releaseDir, 'release-artifacts.json');
     writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
     return manifestPath;
 }
-export function packageReleaseArtifacts() {
-    const packageJson = readJsonFile(resolve(PROJECT_ROOT, 'package.json'));
-    rmSync(RELEASE_DIR, { recursive: true, force: true });
-    mkdirSync(RELEASE_DIR, { recursive: true });
-    const extensionArchive = createExtensionArchive(packageJson);
-    const npmPackageTarball = createNpmPackageTarball();
+export function packageReleaseArtifacts(options) {
+    const releaseDir = options.releaseDir ?? resolve(options.projectRoot, 'artifacts', 'release');
+    const packageJson = readJsonFile(resolve(options.projectRoot, 'package.json'));
+    rmSync(releaseDir, { recursive: true, force: true });
+    mkdirSync(releaseDir, { recursive: true });
+    const extensionArchive = createExtensionArchive(packageJson, options.projectRoot, releaseDir);
+    const npmPackageTarball = createNpmPackageTarball({
+        projectRoot: options.projectRoot,
+        releaseDir,
+        spawn: options.spawn,
+    });
     const manifest = {
         version: packageJson.version,
-        extensionArchive: toProjectRelative(extensionArchive),
-        npmPackageTarball: toProjectRelative(npmPackageTarball),
+        extensionArchive: toProjectRelative(options.projectRoot, extensionArchive),
+        npmPackageTarball: toProjectRelative(options.projectRoot, npmPackageTarball),
     };
-    writeReleaseManifest(manifest);
+    writeReleaseManifest(manifest, releaseDir);
     return manifest;
 }
-function main() {
-    const manifest = packageReleaseArtifacts();
-    console.log(`Created extension archive: ${manifest.extensionArchive}`);
-    console.log(`Created npm package tarball: ${manifest.npmPackageTarball}`);
-    console.log(`Created release manifest: ${toProjectRelative(resolve(RELEASE_DIR, 'release-artifacts.json'))}`);
-}
-if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
-    try {
-        main();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[package:release] ${message}`);
-        process.exit(1);
-    }
-}

package/dist/node-server/routes/fetch-proxy.d.ts

@@ -1,4 +1,5 @@
-import type { Express } from 'express';
+import { Transform } from 'node:stream';
+import type { Express, Request, Response } from 'express';
 import type { SecretProxyManager } from '../secrets/proxy-manager.js';
 import { AgentActivityTracker } from './agent-activity.js';
 export interface FetchProxyDeps {
@@ -13,6 +14,43 @@ export interface FetchProxyDeps {
      */
     logger?: Pick<Console, 'log' | 'warn' | 'error'>;
 }
+export declare function attachUpstreamAbort(res: Response): {
+    controller: AbortController;
+    detach: () => void;
+};
+/** Get the body — either from express.json()'s parsed body or raw chunks. */
+export declare function collectRawBody(req: Request): Promise<Buffer>;
+/**
+ * Build the forwarded header set: copy non-hop-by-hop headers, then restore
+ * the forbidden-header transports (Cookie/Origin/Referer/Proxy-*) the browser
+ * could not send via fetch(). `accept-encoding` is skipped so undici
+ * negotiates gzip/br and decompresses transparently (#3037).
+ */
+export declare function buildForwardHeaders(req: Request, targetUrl: string): Record<string, string>;
+interface ForbiddenSecret {
+    secretName: string;
+    hostname: string;
+}
+/**
+ * Apply request-side secret injection: unmask headers and URL-embedded
+ * credentials. Mutates `headers` to attach a synthetic Authorization when the
+ * URL carried credentials. Returns the forbidden descriptor when a masked
+ * secret is used against a domain it is not scoped to, else the cleaned URL.
+ */
+export declare function injectRequestSecrets(secretProxy: SecretProxyManager, headers: Record<string, string>, targetUrl: string, targetHostname: string): {
+    forbidden: ForbiddenSecret;
+} | {
+    cleanedUrl: string;
+};
+/**
+ * Buffer-aware UTF-8 secret scrubber. A `StringDecoder` keeps trailing partial
+ * multi-byte sequences out of the scrub so codepoints straddling a chunk
+ * boundary aren't corrupted (fatal for CJK/emoji model output). Pass-through
+ * when the body is non-text or no secrets are configured.
+ */
+export declare function createScrubStream(secretProxy: SecretProxyManager, isText: boolean): Transform;
+/** Stream the upstream body to the client through the secret-scrub transform. */
+export declare function streamUpstreamBody(res: Response, upstream: globalThis.Response, secretProxy: SecretProxyManager, detachClientClose: () => void): void;
 /**
  * Fetch proxy — forwards cross-origin requests from the browser to bypass
  * CORS (used by just-bash's curl, which calls the browser's fetch() API).
@@ -20,3 +58,4 @@ export interface FetchProxyDeps {
  * checks req.body first.
  */
 export declare function registerFetchProxyRoute(app: Express, deps: FetchProxyDeps): void;
+export {};

package/dist/node-server/routes/fetch-proxy.js

@@ -4,6 +4,18 @@ import { HMAC_SIGN_HEADER, isFormContentType, isLoopbackOrigin, isTextContentTyp
 import { createMaybeGunzipStream } from '../fetch-proxy-gzip.js';
 import { buildFetchProxyExposeHeaders, FETCH_PROXY_CONTENT_LENGTH_HEADER, FETCH_PROXY_SKIP_HEADERS, FETCH_PROXY_SKIP_RESPONSE_HEADERS, FETCH_PROXY_SKIP_RESPONSE_PREFIXES, } from '../fetch-proxy-headers.js';
 import { AgentActivityTracker, registerAgentActivityRoute } from './agent-activity.js';
+export function attachUpstreamAbort(res) {
+    const controller = new AbortController();
+    const onClose = () => {
+        if (!res.writableEnded)
+            controller.abort();
+    };
+    res.on('close', onClose);
+    return {
+        controller,
+        detach: () => res.off('close', onClose),
+    };
+}
 /** Pick the first value of a possibly-multi-valued request header. */
 function firstHeaderValue(value) {
     if (value === undefined)
@@ -11,7 +23,7 @@ function firstHeaderValue(value) {
     return Array.isArray(value) ? value[0] : value;
 }
 /** Get the body — either from express.json()'s parsed body or raw chunks. */
-async function collectRawBody(req) {
+export async function collectRawBody(req) {
     if (req.body && typeof req.body === 'object' && Object.keys(req.body).length > 0) {
         // Body was already parsed by express.json() — re-serialize it.
         return Buffer.from(JSON.stringify(req.body), 'utf-8');
@@ -28,7 +40,7 @@ async function collectRawBody(req) {
  * could not send via fetch(). `accept-encoding` is skipped so undici
  * negotiates gzip/br and decompresses transparently (#3037).
  */
-function buildForwardHeaders(req, targetUrl) {
+export function buildForwardHeaders(req, targetUrl) {
     const headers = {};
     for (const [key, value] of Object.entries(req.headers)) {
         if (!FETCH_PROXY_SKIP_HEADERS.has(key) && typeof value === 'string') {
@@ -82,7 +94,7 @@ function buildForwardHeaders(req, targetUrl) {
  * URL carried credentials. Returns the forbidden descriptor when a masked
  * secret is used against a domain it is not scoped to, else the cleaned URL.
  */
-function injectRequestSecrets(secretProxy, headers, targetUrl, targetHostname) {
+export function injectRequestSecrets(secretProxy, headers, targetUrl, targetHostname) {
     if (!secretProxy.hasSecrets())
         return { cleanedUrl: targetUrl };
     const headerResult = secretProxy.unmaskHeaders(headers, targetHostname);
@@ -200,7 +212,7 @@ function forwardUpstreamHeaders(res, upstream, secretProxy) {
  * boundary aren't corrupted (fatal for CJK/emoji model output). Pass-through
  * when the body is non-text or no secrets are configured.
  */
-function createScrubStream(secretProxy, isText) {
+export function createScrubStream(secretProxy, isText) {
     const utf8Decoder = new StringDecoder('utf8');
     return new Transform({
         transform(chunk, _enc, cb) {
@@ -241,7 +253,7 @@ function createScrubStream(secretProxy, isText) {
     });
 }
 /** Stream the upstream body to the client through the secret-scrub transform. */
-function streamUpstreamBody(res, upstream, secretProxy, detachClientClose) {
+export function streamUpstreamBody(res, upstream, secretProxy, detachClientClose) {
     const isText = isTextContentType(upstream.headers.get('content-type') ?? '');
     const upstreamStream = Readable.fromWeb(upstream.body);
     // Text only: a real `application/gzip` / `.tar.gz` body is a gzip member
@@ -349,13 +361,9 @@ export function registerFetchProxyRoute(app, deps) {
             // streams (LLM SSE completions) are torn down promptly. Listen on
             // `res.on('close')`, not `req.on('close')` — Node fires req close as soon
             // as the request body is consumed, which would abort before fetch starts.
-            const abortController = new AbortController();
-            onClientClose = () => {
-                if (!res.writableEnded)
-                    abortController.abort();
-            };
-            res.on('close', onClientClose);
-            fetchInit.signal = abortController.signal;
+            const upstreamAbort = attachUpstreamAbort(res);
+            onClientClose = upstreamAbort.detach;
+            fetchInit.signal = upstreamAbort.controller.signal;
             const upstream = await fetch(injection.cleanedUrl, fetchInit);
             logger.log(`[fetch-proxy] ${req.method} ${targetUrl} ← ${upstream.status}`);
             forwardUpstreamHeaders(res, upstream, secretProxy);

package/dist/node-server/routes/secrets.d.ts

@@ -1,14 +1,36 @@
-import { type Express } from 'express';
+import { type Express, type Response } from 'express';
 import type { EnvSecretStore } from '../secrets/env-secret-store.js';
 import type { OauthSecretStore } from '../secrets/oauth-secret-store.js';
 import type { SecretProxyManager } from '../secrets/proxy-manager.js';
+import { handleDaSignAndForward, handleS3SignAndForward } from '../secrets/sign-and-forward.js';
 export interface SecretRoutesDeps {
     secretStore: EnvSecretStore;
     secretProxy: SecretProxyManager;
     oauthStore: OauthSecretStore;
     /** When true, the full sign-and-forward error is logged for the local operator. */
     devMode: boolean;
+    handleS3?: typeof handleS3SignAndForward;
+    handleDa?: typeof handleDaSignAndForward;
 }
+/**
+ * Sign-and-forward failure responder. Logs only a generic line + trace id —
+ * the err.message can carry profile names, bucket names, or partial URLs we
+ * don't want in shared log aggregators. The trace id lets the user correlate
+ * the 500 they got with the server log; the detail goes to the file logger
+ * (above DEBUG) only when devMode is on.
+ */
+export declare function respondSignAndForwardError(res: Response, err: unknown, devMode: boolean, label: string): void;
+/**
+ * Scope edit handler — updates allowed domains of an existing secret without
+ * changing its value. Checks session store first, then falls back to persisted.
+ */
+export declare function handleScopeEdit(res: Response, name: unknown, domains: unknown, secretStore: EnvSecretStore, secretProxy: SecretProxyManager): Promise<Response>;
+/**
+ * Persisted/session delete handler — checks the session store first so a
+ * session shadow does not leak through after deletion, then falls back to the
+ * persisted store. Reloads the masking pipeline either way.
+ */
+export declare function handleDeleteSecret(name: string | undefined, res: Response, secretStore: EnvSecretStore, secretProxy: SecretProxyManager): Promise<Response>;
 /**
  * Secret management API — direct .env file access (no browser needed). The
  * `secretStore` is wired into `secretProxy` so the fetch-proxy and the