fix(remote): preserve tenant scope for proxy artifact downloads

Author: thymikee

src/daemon/__tests__/http-contract.test.ts

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict';
 import {
   buildDaemonHttpAuthHeaders,
   buildDaemonHttpBaseUrl,
+  buildDaemonHttpTenantHeaders,
   buildDaemonHttpUrl,
 } from '../http-contract.ts';
 
@@ -35,3 +36,10 @@ test('buildDaemonHttpAuthHeaders writes both supported daemon auth headers', ()
   });
   assert.deepEqual(buildDaemonHttpAuthHeaders(''), {});
 });
+
+test('buildDaemonHttpTenantHeaders omits blank tenant identities', () => {
+  assert.deepEqual(buildDaemonHttpTenantHeaders(' tenant-a '), {
+    'x-agent-device-tenant': 'tenant-a',
+  });
+  assert.deepEqual(buildDaemonHttpTenantHeaders(''), {});
+});

src/daemon/http-contract.ts

@@ -1,4 +1,5 @@
 export const DAEMON_HTTP_BASE_PATH = '/agent-device';
+export const DAEMON_HTTP_TENANT_HEADER = 'x-agent-device-tenant';
 
 export function buildDaemonHttpBaseUrl(baseUrl: string): string {
   return buildDaemonHttpUrl(baseUrl, DAEMON_HTTP_BASE_PATH);
@@ -17,3 +18,9 @@ export function buildDaemonHttpAuthHeaders(token: string | undefined): Record<st
     'x-agent-device-token': normalizedToken,
   };
 }
+
+export function buildDaemonHttpTenantHeaders(tenantId: string | undefined): Record<string, string> {
+  const normalizedTenantId = tenantId?.trim();
+  if (!normalizedTenantId) return {};
+  return { [DAEMON_HTTP_TENANT_HEADER]: normalizedTenantId };
+}

src/daemon/server/http-server.ts

@@ -26,6 +26,7 @@ import {
   shouldStreamRequestProgress,
 } from '../request-progress-protocol.ts';
 import { buildDaemonHealthPayload } from '../http-health.ts';
+import { DAEMON_HTTP_TENANT_HEADER } from '../http-contract.ts';
 import { sendRestJsonError, statusCodeForNormalizedError } from '../http-errors.ts';
 import { tryHandleUploadHttpRoute } from '../upload-http.ts';
 import { tryHandleDownloadableArtifactHttpRoute } from '../downloadable-artifact-http.ts';
@@ -753,6 +754,7 @@ async function authorizeAuxiliaryHttpRequest(params: {
 }): Promise<{ tenantId?: string } | null> {
   const { req, res, authHook, expectedToken, daemonRequest } = params;
   const token = resolveToken({}, req.headers);
+  const tenantId = normalizeTenantId(readHeaderValue(req.headers, DAEMON_HTTP_TENANT_HEADER));
   const tokenError = enforceDaemonToken(token, expectedToken);
   if (tokenError) {
     sendRestJsonError(res, tokenError);
@@ -772,6 +774,7 @@ async function authorizeAuxiliaryHttpRequest(params: {
       session: 'default',
       command: daemonRequest.command,
       positionals: daemonRequest.positionals,
+      ...(tenantId ? { meta: { tenantId } } : {}),
     },
   });
   if (!authResult.ok) {
@@ -789,7 +792,12 @@ async function authorizeAuxiliaryHttpRequest(params: {
     return null;
   }
 
-  return { tenantId: authResult.tenantId };
+  return { tenantId: authResult.tenantId ?? tenantId };
+}
+
+function readHeaderValue(headers: IncomingHttpHeaders, name: string): string | undefined {
+  const value = headers[name];
+  return typeof value === 'string' ? value : undefined;
 }
 
 function enforceDaemonToken(

src/remote/daemon-artifacts.ts

@@ -5,7 +5,10 @@ import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { AppError } from '../kernel/errors.ts';
 import type { DaemonArtifact, DaemonRequest, DaemonResponse } from '../daemon/types.ts';
-import { buildDaemonHttpAuthHeaders } from '../daemon/http-contract.ts';
+import {
+  buildDaemonHttpAuthHeaders,
+  buildDaemonHttpTenantHeaders,
+} from '../daemon/http-contract.ts';
 import {
   appendRecordingExtensionWhenMissing,
   recordingExtensionForPlatform,
@@ -312,6 +315,7 @@ export async function materializeRemoteArtifacts(
       artifactId: artifact.artifactId,
       destinationPath: localPath,
       requestId: req.meta?.requestId,
+      tenantId: req.meta?.tenantId,
     });
     nextData[artifact.field] = localPath;
     nextArtifacts.push({
@@ -341,6 +345,7 @@ type DownloadRemoteArtifactParams = {
   artifactId: string;
   destinationPath: string;
   requestId?: string;
+  tenantId?: string;
   timeoutMs?: number;
 };
 
@@ -368,7 +373,10 @@ export async function downloadRemoteArtifact(params: DownloadRemoteArtifactParam
         port: artifactUrl.port,
         method: 'GET',
         path: artifactUrl.pathname + artifactUrl.search,
-        headers: buildDaemonHttpAuthHeaders(params.token),
+        headers: {
+          ...buildDaemonHttpAuthHeaders(params.token),
+          ...buildDaemonHttpTenantHeaders(params.tenantId),
+        },
       },
       (res) => {
         if ((res.statusCode ?? 500) >= 400) {

src/remote/daemon-proxy.ts

@@ -7,6 +7,7 @@ import { readNodeHttpRequestBody } from '../utils/node-http.ts';
 import { timingSafeStringEqual } from '../utils/timing-safe-equal.ts';
 import {
   DAEMON_HTTP_BASE_PATH,
+  DAEMON_HTTP_TENANT_HEADER,
   buildDaemonHttpAuthHeaders,
   buildDaemonHttpUrl,
 } from '../daemon/http-contract.ts';
@@ -31,6 +32,7 @@ const FORWARDED_REQUEST_HEADERS = [
   'x-artifact-filename',
   'x-artifact-hash',
   'x-artifact-hash-algorithm',
+  DAEMON_HTTP_TENANT_HEADER,
 ];
 const FORWARDED_RESPONSE_HEADERS = ['content-type', 'content-disposition', 'x-request-id'];
 

test/integration/provider-scenarios/remote-proxy-artifact-tenant.test.ts

@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'vitest';
+import { createAgentDeviceClient } from '../../../src/agent-device-client.ts';
+import {
+  cleanupDownloadableArtifact,
+  trackDownloadableArtifact,
+} from '../../../src/daemon/artifact-tracking.ts';
+import { finalizeDaemonResponse } from '../../../src/daemon/request-finalization.ts';
+import { createDaemonHttpServer } from '../../../src/daemon/server/http-server.ts';
+import { normalizeAgentDeviceError } from '../../../src/kernel/errors.ts';
+import { downloadRemoteArtifact } from '../../../src/remote/daemon-artifacts.ts';
+import { createDaemonProxyServer } from '../../../src/remote/daemon-proxy.ts';
+import {
+  closeLoopbackServer,
+  listenOnLoopback,
+  skipWhenLoopbackUnavailable,
+} from '../../../src/__tests__/test-utils/loopback.ts';
+
+const TENANT = 'local-proxy-tenant';
+const OTHER_TENANT = 'other-tenant';
+
+test('Provider-backed integration local proxy materializes tenant-scoped screenshots', async (t) => {
+  if (await skipWhenLoopbackUnavailable(t, 'local proxy artifact tenant coverage')) return;
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-proxy-artifact-tenant-'));
+  const remoteScreenshotPath = path.join(tempDir, 'remote-shot.png');
+  const localScreenshotPath = path.join(tempDir, 'local-shot.png');
+  const rejectedScreenshotPath = path.join(tempDir, 'rejected-shot.png');
+  fs.writeFileSync(remoteScreenshotPath, 'tenant-scoped-png');
+  const artifactIds: string[] = [];
+  const upstream = await createDaemonHttpServer({
+    token: 'upstream-token',
+    handleRequest: async (req) => {
+      assert.equal(req.command, 'screenshot');
+      assert.equal(req.meta?.tenantId, TENANT);
+      assert.equal(req.meta?.runId, 'local-proxy-run');
+      assert.equal(req.meta?.sessionIsolation, 'tenant');
+      return finalizeDaemonResponse(
+        req,
+        { ok: true, data: { path: remoteScreenshotPath } },
+        (artifact) => {
+          const artifactId = trackDownloadableArtifact(artifact);
+          artifactIds.push(artifactId);
+          return artifactId;
+        },
+      );
+    },
+  });
+  const protectedArtifactId = trackDownloadableArtifact({
+    artifactPath: remoteScreenshotPath,
+    tenantId: TENANT,
+    artifactType: 'screenshot',
+    fileName: 'remote-shot.png',
+  });
+  artifactIds.push(protectedArtifactId);
+  const proxy = createDaemonProxyServer({
+    upstreamBaseUrl: `http://127.0.0.1:${await listenOnLoopback(upstream)}`,
+    upstreamToken: 'upstream-token',
+    clientToken: 'proxy-token',
+  });
+
+  try {
+    const proxyPort = await listenOnLoopback(proxy);
+    const daemonBaseUrl = `http://127.0.0.1:${proxyPort}/agent-device`;
+
+    await assert.rejects(
+      async () =>
+        await downloadRemoteArtifact({
+          baseUrl: daemonBaseUrl,
+          token: 'proxy-token',
+          tenantId: OTHER_TENANT,
+          artifactId: protectedArtifactId,
+          destinationPath: rejectedScreenshotPath,
+        }),
+      (error: unknown) => {
+        const normalized = normalizeAgentDeviceError(error);
+        assert.equal(normalized.details?.statusCode, 401);
+        assert.match(String(normalized.details?.body), /different tenant/i);
+        return true;
+      },
+    );
+    assert.equal(fs.existsSync(rejectedScreenshotPath), false);
+
+    const client = createAgentDeviceClient({
+      daemonBaseUrl,
+      daemonAuthToken: 'proxy-token',
+      tenant: TENANT,
+      runId: 'local-proxy-run',
+      sessionIsolation: 'tenant',
+      stateDir: tempDir,
+    });
+    const screenshot = await client.capture.screenshot({ path: localScreenshotPath });
+
+    assert.equal(screenshot.path, localScreenshotPath);
+    assert.equal(fs.readFileSync(localScreenshotPath, 'utf8'), 'tenant-scoped-png');
+  } finally {
+    for (const artifactId of artifactIds) cleanupDownloadableArtifact(artifactId);
+    await closeLoopbackServer(proxy);
+    await closeLoopbackServer(upstream);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});