@agenthippo-ai/agenthippo 0.1.0

package/out/test/gateway-outbound.test.js

@@ -0,0 +1,531 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const outboundHandles_js_1 = require("../gateway/outboundHandles.js");
+const outboundPaths_js_1 = require("../gateway/outboundPaths.js");
+const runtime_js_1 = require("../cli/runtime.js");
+const outboundPaths_js_2 = require("../gateway/outboundPaths.js");
+const outboundSend_js_1 = require("../gateway/outboundSend.js");
+async function withTempStore(fn) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-outbound-test-'));
+    const file = path.join(dir, 'gateway-outbound.json');
+    (0, outboundHandles_js_1._setOutboundHandleStorePathForTest)(file);
+    (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+    try {
+        return await fn(file);
+    }
+    finally {
+        (0, outboundHandles_js_1._setOutboundHandleStorePathForTest)(undefined);
+        (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+suite('Gateway outbound paths', () => {
+    test('safeGatewaySessionDirId sanitizes gateway session keys', () => {
+        assert.strictEqual((0, outboundPaths_js_1.safeGatewaySessionDirId)('agent:data-analyst:slack:channel:C999'), 'agent_data-analyst_slack_channel_C999');
+    });
+    test('resolveGatewayOutboundFilePath prefers chat session id', () => {
+        const file = (0, outboundPaths_js_1.resolveGatewayOutboundFilePath)({
+            workspaceRoot: '/tmp/ws',
+            chatSessionId: 'abc-123',
+            gatewaySessionKey: 'agent:data-analyst:slack:channel:C999',
+        });
+        assert.strictEqual(file, (0, outboundPaths_js_1.getGatewayOutboundFilePath)('/tmp/ws', 'abc-123'));
+    });
+    test('resolveGatewayOutboundFilePath falls back to gateway session key', () => {
+        const file = (0, outboundPaths_js_1.resolveGatewayOutboundFilePath)({
+            workspaceRoot: '/tmp/ws',
+            gatewaySessionKey: 'agent:data-analyst:slack:channel:C999',
+        });
+        assert.strictEqual(file, (0, outboundPaths_js_1.getGatewayOutboundFilePath)('/tmp/ws', (0, outboundPaths_js_1.safeGatewaySessionDirId)('agent:data-analyst:slack:channel:C999')));
+    });
+    test('buildSessionEnvPatch sets chat session env vars and outbound file', () => {
+        const env = (0, runtime_js_1.buildSessionEnvPatch)({
+            workspaceRoot: '/tmp/ws',
+            chatSessionId: 'abc-123',
+        });
+        assert.strictEqual(env[runtime_js_1.AGENTIDE_CHAT_SESSION_ID_ENV], 'abc-123');
+        assert.strictEqual(env[runtime_js_1.AGENTHIPPO_CHAT_SESSION_ID_ENV], 'abc-123');
+        assert.strictEqual(env[outboundPaths_js_2.AGENTHIPPO_GATEWAY_OUTBOUND_FILE_ENV], (0, outboundPaths_js_1.getGatewayOutboundFilePath)('/tmp/ws', 'abc-123'));
+    });
+    test('resolveGatewayOutboundFilePath sanitizes gateway session keys for env paths', () => {
+        const key = 'agent:data-analyst:slack:channel:c0b1smfltsl';
+        const file = (0, outboundPaths_js_1.resolveGatewayOutboundFilePath)({
+            workspaceRoot: '/tmp/ws',
+            chatSessionId: key,
+        });
+        assert.strictEqual(file, (0, outboundPaths_js_1.getGatewayOutboundFilePath)('/tmp/ws', (0, outboundPaths_js_1.safeGatewaySessionDirId)(key)));
+    });
+});
+suite('Gateway outbound handles', () => {
+    test('upserts and reads last handle with explicit target', async () => {
+        await withTempStore(async (storePath) => {
+            const params = {
+                message: 'hi',
+                channel: 'slack',
+                accountId: 'default',
+                target: 'user:U123',
+                threadId: '1712345678.9012',
+                sessionKey: 'agent:data-analyst:main',
+                senderId: 'U123',
+                senderName: 'Tom',
+                idempotencyKey: 'run-1',
+            };
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', params, 'run-1');
+            const handle = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.ok(handle);
+            assert.strictEqual(handle.target, 'user:U123');
+            assert.strictEqual(handle.channel, 'slack');
+            assert.strictEqual(handle.threadId, '1712345678.9012');
+            assert.strictEqual(handle.inboundCount, 1);
+        });
+    });
+    test('resolveGatewayOutboundHandle maps default to legacy Default store key', async () => {
+        await withTempStore(async (storePath) => {
+            const params = {
+                message: 'hi',
+                channel: 'slack',
+                target: 'channel:C0B0GV2JWLX',
+                idempotencyKey: 'run-legacy-default',
+            };
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'Default', params);
+            const byLower = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'default');
+            assert.ok(byLower);
+            assert.strictEqual(byLower.target, 'channel:C0B0GV2JWLX');
+            const byExact = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'Default');
+            assert.strictEqual(byExact?.target, 'channel:C0B0GV2JWLX');
+        });
+    });
+    test('stores pack id as store key and gatewayAgentId on handle', async () => {
+        await withTempStore(async (storePath) => {
+            const params = {
+                message: 'hi',
+                channel: 'slack',
+                target: 'channel:C0B1SMMJCQ0',
+                sessionKey: 'agent:ide-agenthippo-vscode-data-analyst:slack:channel:c0b1smmjcq0',
+                idempotencyKey: 'run-pack',
+            };
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', params, 'run-pack', {
+                gatewayAgentId: 'ide-agenthippo-vscode-data-analyst',
+            });
+            const handle = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.ok(handle);
+            assert.strictEqual(handle.agentId, 'data-analyst');
+            assert.strictEqual(handle.gatewayAgentId, 'ide-agenthippo-vscode-data-analyst');
+            const byGatewayId = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'ide-agenthippo-vscode-data-analyst');
+            assert.strictEqual(byGatewayId, undefined);
+            const resolved = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.strictEqual(resolved?.target, 'channel:C0B1SMMJCQ0');
+        });
+    });
+    test('infers target from sessionKey channel peer', async () => {
+        await withTempStore(async (storePath) => {
+            const params = {
+                message: 'hi',
+                channel: 'slack',
+                sessionKey: 'agent:data-analyst:slack:channel:C999',
+                idempotencyKey: 'run-2',
+            };
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', params);
+            const handle = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.ok(handle);
+            assert.strictEqual(handle.target, 'channel:C999');
+        });
+    });
+    test('prefers channel target over senderId when sessionKey is a channel', async () => {
+        await withTempStore(async (storePath) => {
+            const params = {
+                message: 'hi',
+                channel: 'slack',
+                sessionKey: 'agent:default:slack:channel:c0b1smmjcq0',
+                senderId: 'U0B1218AEFN',
+                senderName: 'T',
+                idempotencyKey: 'run-channel',
+            };
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'default', params);
+            const handle = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'default');
+            assert.ok(handle);
+            assert.strictEqual(handle.target, 'channel:C0B1SMMJCQ0');
+        });
+    });
+    test('infers Slack user target from dm sessionKey peer', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'default', {
+                message: 'hi',
+                channel: 'slack',
+                sessionKey: 'agent:default:slack:dm:u0b1218aefn',
+                idempotencyKey: 'run-dm',
+            });
+            const handle = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'default');
+            assert.ok(handle);
+            assert.strictEqual(handle.target, 'user:U0B1218AEFN');
+        });
+    });
+    test('keeps multiple targets per agent and lastByAgent pointer', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'slack',
+                target: 'channel:C111',
+                idempotencyKey: '1',
+            });
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'b',
+                channel: 'slack',
+                target: 'channel:C222',
+                idempotencyKey: '2',
+            });
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'c',
+                channel: 'slack',
+                target: 'channel:C111',
+                idempotencyKey: '3',
+            });
+            const targets = await (0, outboundHandles_js_1.listGatewayOutboundTargets)(storePath, 'data-analyst');
+            assert.strictEqual(targets.length, 2);
+            assert.strictEqual(targets[0].target, 'channel:C111');
+            assert.strictEqual(targets[1].target, 'channel:C222');
+            assert.strictEqual(targets[0].inboundCount, 2);
+            const last = await (0, outboundHandles_js_1.getLastGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.strictEqual(last?.target, 'channel:C111');
+            const byTarget = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', { target: 'channel:C111' });
+            assert.strictEqual(byTarget?.target, 'channel:C111');
+            assert.strictEqual(byTarget?.inboundCount, 2);
+        });
+    });
+    test('buildGatewayOutboundHandleKey separates threads', () => {
+        assert.strictEqual((0, outboundHandles_js_1.buildGatewayOutboundHandleKey)('channel:C1'), 'channel:C1::');
+        assert.strictEqual((0, outboundHandles_js_1.buildGatewayOutboundHandleKey)('channel:C1', '111.222'), 'channel:C1::thread:111.222');
+    });
+    test('buildGatewayOutboundSendArgs includes thread and account', () => {
+        const args = (0, outboundSend_js_1.buildGatewayOutboundSendArgs)({
+            agentId: 'data-analyst',
+            channel: 'slack',
+            accountId: 'default',
+            target: 'user:U123',
+            threadId: '111.222',
+            firstSeenAt: 1,
+            lastSeenAt: 2,
+            inboundCount: 1,
+        }, 'Hello');
+        assert.deepStrictEqual(args, [
+            'message', 'send',
+            '--channel', 'slack',
+            '--target', 'user:U123',
+            '--message', 'Hello',
+            '--account', 'default',
+            '--thread-id', '111.222',
+        ]);
+    });
+    test('resolveGatewayOutboundHandle returns undefined when explicit target is missing', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'slack',
+                target: 'channel:C111',
+                idempotencyKey: '1',
+            });
+            const missing = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', { target: 'channel:C999' });
+            assert.strictEqual(missing, undefined);
+            const defaultRoute = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst');
+            assert.strictEqual(defaultRoute?.target, 'channel:C111');
+        });
+    });
+    test('merges stored gateway-session routes into a chat-session store', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-outbound-merge-test-'));
+        const sourceStorePath = path.join(dir, 'agent_default_slack_channel_c111', 'gateway-outbound.json');
+        const targetStorePath = path.join(dir, 'chat-session-123', 'gateway-outbound.json');
+        (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+        try {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(sourceStorePath, 'default', {
+                message: 'hi',
+                channel: 'slack',
+                sessionKey: 'agent:default:slack:channel:c111',
+                idempotencyKey: 'run-source',
+            });
+            const merged = await (0, outboundHandles_js_1.mergeGatewayOutboundHandles)(sourceStorePath, targetStorePath, 'default');
+            assert.strictEqual(merged, 1);
+            const resolved = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(targetStorePath, 'default');
+            assert.strictEqual(resolved?.target, 'channel:C111');
+            assert.ok(fs.existsSync(targetStorePath));
+        }
+        finally {
+            (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    test('resolveGatewayOutboundHandle matches Slack targets case-insensitively', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'slack',
+                target: 'channel:C01234567',
+                idempotencyKey: '1',
+            });
+            const resolved = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', { target: 'channel:c01234567' });
+            assert.strictEqual(resolved?.target, 'channel:C01234567');
+        });
+    });
+    test('resolveGatewayOutboundHandle preserves non-Slack target casing', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'telegram',
+                target: '123456789',
+                idempotencyKey: '1',
+            });
+            const resolved = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', { target: '123456789' });
+            assert.strictEqual(resolved?.target, '123456789');
+            assert.strictEqual(resolved?.channel, 'telegram');
+        });
+    });
+    test('resolveGatewayOutboundHandle requires exact thread when --thread-id is set', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'slack',
+                target: 'channel:C111',
+                threadId: '111.222',
+                idempotencyKey: '1',
+            });
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'b',
+                channel: 'slack',
+                target: 'channel:C111',
+                idempotencyKey: '2',
+            });
+            const wrongThread = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', {
+                target: 'channel:C111',
+                threadId: '999.000',
+            });
+            assert.strictEqual(wrongThread, undefined);
+            const exactThread = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', {
+                target: 'channel:C111',
+                threadId: '111.222',
+            });
+            assert.strictEqual(exactThread?.threadId, '111.222');
+        });
+    });
+    test('resolveGatewayOutboundHandle prefers non-threaded route when thread omitted', async () => {
+        await withTempStore(async (storePath) => {
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'a',
+                channel: 'slack',
+                target: 'channel:C111',
+                threadId: '111.222',
+                idempotencyKey: '1',
+            });
+            await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                message: 'b',
+                channel: 'slack',
+                target: 'channel:C111',
+                idempotencyKey: '2',
+            });
+            const resolved = await (0, outboundHandles_js_1.resolveGatewayOutboundHandle)(storePath, 'data-analyst', { target: 'channel:C111' });
+            assert.strictEqual(resolved?.threadId, undefined);
+        });
+    });
+    test('serializes concurrent upserts without losing routes', async () => {
+        await withTempStore(async (storePath) => {
+            await Promise.all([
+                (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                    message: 'a',
+                    channel: 'slack',
+                    target: 'channel:C111',
+                    idempotencyKey: '1',
+                }),
+                (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                    message: 'b',
+                    channel: 'slack',
+                    target: 'channel:C222',
+                    idempotencyKey: '2',
+                }),
+                (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'data-analyst', {
+                    message: 'c',
+                    channel: 'slack',
+                    target: 'channel:C111',
+                    idempotencyKey: '3',
+                }),
+            ]);
+            const targets = await (0, outboundHandles_js_1.listGatewayOutboundTargets)(storePath, 'data-analyst');
+            assert.strictEqual(targets.length, 2);
+            const c111 = targets.find(t => t.target === 'channel:C111');
+            assert.strictEqual(c111?.inboundCount, 2);
+        });
+    });
+    test('buildGatewayRpcCommand uses send RPC method', () => {
+        const command = (0, outboundSend_js_1.buildGatewayRpcCommand)({
+            agentId: 'data-analyst',
+            channel: 'slack',
+            target: 'channel:C111',
+            firstSeenAt: 1,
+            lastSeenAt: 2,
+            inboundCount: 1,
+        }, 'Hello');
+        assert.strictEqual(command[0], outboundSend_js_1.GATEWAY_OUTBOUND_RPC_METHOD);
+        assert.strictEqual(JSON.parse(command[1]).to, 'channel:C111');
+        assert.strictEqual(JSON.parse(command[1]).message, 'Hello');
+    });
+    test('buildGatewaySendParams matches openclaw SendParamsSchema fields', () => {
+        const params = (0, outboundSend_js_1.buildGatewaySendParams)({
+            agentId: 'data-analyst',
+            channel: 'slack',
+            accountId: 'default',
+            target: 'channel:C111',
+            threadId: '111.222',
+            sessionKey: 'agent:data-analyst:slack:channel:C111',
+            firstSeenAt: 1,
+            lastSeenAt: 2,
+            inboundCount: 1,
+        }, 'Hello');
+        assert.strictEqual(outboundSend_js_1.GATEWAY_OUTBOUND_RPC_METHOD, 'send');
+        assert.strictEqual(params.to, 'channel:C111');
+        assert.strictEqual(params.message, 'Hello');
+        assert.strictEqual(params.channel, 'slack');
+        assert.strictEqual(params.accountId, 'default');
+        assert.strictEqual(params.threadId, '111.222');
+        assert.strictEqual(params.sessionKey, 'agent:data-analyst:slack:channel:C111');
+        assert.strictEqual(params.agentId, 'data-analyst');
+        assert.ok(typeof params.idempotencyKey === 'string');
+        assert.ok(!('mediaUrl' in params));
+    });
+    test('buildGatewaySendParams adds mediaUrl only when media is provided', () => {
+        const handle = {
+            agentId: 'data-analyst',
+            channel: 'slack',
+            target: 'channel:C111',
+            sessionKey: 'agent:data-analyst:slack:channel:C111',
+            firstSeenAt: 1,
+            lastSeenAt: 2,
+            inboundCount: 1,
+        };
+        const withMedia = (0, outboundSend_js_1.buildGatewaySendParams)(handle, 'Hello', '/tmp/chart.png');
+        assert.strictEqual(withMedia.mediaUrl, '/tmp/chart.png');
+        const withoutMedia = (0, outboundSend_js_1.buildGatewaySendParams)(handle, 'Hello');
+        assert.ok(!('mediaUrl' in withoutMedia));
+    });
+    test('buildGatewayOutboundSendArgs includes --media when provided', () => {
+        const args = (0, outboundSend_js_1.buildGatewayOutboundSendArgs)({
+            agentId: 'data-analyst',
+            channel: 'slack',
+            target: 'channel:C111',
+            firstSeenAt: 1,
+            lastSeenAt: 2,
+            inboundCount: 1,
+        }, 'Hello', '/tmp/chart.png');
+        assert.ok(args.includes('--media'));
+        assert.strictEqual(args[args.indexOf('--media') + 1], '/tmp/chart.png');
+    });
+    test('stageLocalMediaIfNeeded passes through URLs and empty values', () => {
+        assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)(undefined), undefined);
+        assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)('https://example.com/x.png'), 'https://example.com/x.png');
+        assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)('file:///tmp/x.png'), 'file:///tmp/x.png');
+    });
+    test('stageLocalMediaIfNeeded treats a Windows drive path as local, not a URL', () => {
+        // A non-existent Windows-style path: not URL-detected, attempted as a local file,
+        // missing -> returned unchanged (proves `C:\` is not mistaken for a URL scheme).
+        assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)('C:\\Users\\me\\chart.png'), 'C:\\Users\\me\\chart.png');
+        assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)('C:/Users/me/chart.png'), 'C:/Users/me/chart.png');
+    });
+    test('stageLocalMediaIfNeeded honors OPENCLAW_STATE_DIR / CLAWDBOT_STATE_DIR overrides', () => {
+        const dirA = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-ovA-'));
+        const dirB = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-ovB-'));
+        const srcDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-src-'));
+        const src = path.join(srcDir, 'pic.png');
+        fs.writeFileSync(src, 'X');
+        const prevO = process.env.OPENCLAW_STATE_DIR;
+        const prevC = process.env.CLAWDBOT_STATE_DIR;
+        try {
+            // OPENCLAW_STATE_DIR wins over CLAWDBOT_STATE_DIR.
+            process.env.OPENCLAW_STATE_DIR = dirA;
+            process.env.CLAWDBOT_STATE_DIR = dirB;
+            assert.ok((0, outboundSend_js_1.stageLocalMediaIfNeeded)(src).startsWith(path.join(dirA, 'media')));
+            // Falls back to CLAWDBOT_STATE_DIR when OPENCLAW_STATE_DIR is unset.
+            delete process.env.OPENCLAW_STATE_DIR;
+            assert.ok((0, outboundSend_js_1.stageLocalMediaIfNeeded)(src).startsWith(path.join(dirB, 'media')));
+        }
+        finally {
+            if (prevO === undefined) {
+                delete process.env.OPENCLAW_STATE_DIR;
+            }
+            else {
+                process.env.OPENCLAW_STATE_DIR = prevO;
+            }
+            if (prevC === undefined) {
+                delete process.env.CLAWDBOT_STATE_DIR;
+            }
+            else {
+                process.env.CLAWDBOT_STATE_DIR = prevC;
+            }
+            for (const d of [dirA, dirB, srcDir]) {
+                fs.rmSync(d, { recursive: true, force: true });
+            }
+        }
+    });
+    test('stageLocalMediaIfNeeded copies out-of-sandbox local files into <state>/media', () => {
+        const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-state-'));
+        const srcDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ah-src-'));
+        const src = path.join(srcDir, 'chart.png');
+        fs.writeFileSync(src, 'PNGDATA');
+        const prev = process.env.OPENCLAW_STATE_DIR;
+        process.env.OPENCLAW_STATE_DIR = stateDir;
+        try {
+            const staged = (0, outboundSend_js_1.stageLocalMediaIfNeeded)(src);
+            const stagingDir = path.join(stateDir, 'media');
+            assert.ok(staged && staged.startsWith(stagingDir), `expected staged under ${stagingDir}, got ${staged}`);
+            assert.strictEqual(path.extname(staged), '.png');
+            assert.strictEqual(fs.readFileSync(staged, 'utf-8'), 'PNGDATA');
+            // A file already inside the staging dir is returned as-is (not re-nested).
+            assert.strictEqual((0, outboundSend_js_1.stageLocalMediaIfNeeded)(staged), fs.realpathSync(staged));
+        }
+        finally {
+            if (prev === undefined) {
+                delete process.env.OPENCLAW_STATE_DIR;
+            }
+            else {
+                process.env.OPENCLAW_STATE_DIR = prev;
+            }
+            fs.rmSync(stateDir, { recursive: true, force: true });
+            fs.rmSync(srcDir, { recursive: true, force: true });
+        }
+    });
+});