@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

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

@@ -1,538 +0,0 @@
-"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('safeGatewaySessionDirId rejects dot-only keys (path traversal)', () => {
-        assert.strictEqual((0, outboundPaths_js_1.safeGatewaySessionDirId)('.'), '_');
-        assert.strictEqual((0, outboundPaths_js_1.safeGatewaySessionDirId)('..'), '__');
-        // Slash-separated traversal collapses via the char class, never into dot segments.
-        assert.strictEqual((0, outboundPaths_js_1.safeGatewaySessionDirId)('../../etc'), '.._.._etc');
-        assert.strictEqual((0, outboundPaths_js_1.getGatewayOutboundFilePath)('/tmp/ws', (0, outboundPaths_js_1.safeGatewaySessionDirId)('..')), '/tmp/ws/.agent-hippo/sessions/__/gateway-outbound.json');
-    });
-    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 });
-        }
-    });
-});