@agenthippo-ai/agenthippo 0.1.0

package/out/test/gateway-reset-mappings.test.js

@@ -0,0 +1,221 @@
+"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 gatewayBackup_js_1 = require("../gateway/gatewayBackup.js");
+const gatewayRouteIndex_js_1 = require("../gateway/gatewayRouteIndex.js");
+const outboundHandles_js_1 = require("../gateway/outboundHandles.js");
+const outboundPaths_js_1 = require("../gateway/outboundPaths.js");
+const resetMappings_js_1 = require("../gateway/resetMappings.js");
+function outboundParams(channel, target) {
+    return {
+        message: 'hi',
+        channel,
+        target,
+        idempotencyKey: `${channel}:${target}:${Math.random()}`,
+    };
+}
+async function seedOutbound(workspaceRoot, sessionId, agentId, channel, target) {
+    const storePath = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, (0, outboundPaths_js_1.safeGatewaySessionDirId)(sessionId));
+    await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, agentId, outboundParams(channel, target));
+    return storePath;
+}
+function listBk(dir) {
+    if (!fs.existsSync(dir)) {
+        return [];
+    }
+    return fs.readdirSync(dir).filter((f) => f.endsWith('.bk'));
+}
+suite('Gateway reset mappings', () => {
+    let workspaceRoot;
+    setup(() => {
+        (0, gatewayRouteIndex_js_1._resetGatewayRouteIndexLocksForTest)();
+        (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+        workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-reset-'));
+    });
+    teardown(() => {
+        (0, gatewayRouteIndex_js_1._resetGatewayRouteIndexLocksForTest)();
+        (0, outboundHandles_js_1._resetOutboundHandleStoreLockForTest)();
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    });
+    // --- gatewayBackup helpers ---------------------------------------------------------------
+    test('backupTimestamp is filesystem-safe (no colons/dashes)', () => {
+        const ts = (0, gatewayBackup_js_1.backupTimestamp)(new Date('2026-06-07T15:30:00.123Z'));
+        assert.strictEqual(ts, '20260607T153000Z');
+        assert.ok(!/[:\-]/.test(ts), 'timestamp must not contain : or -');
+    });
+    test('backupPathFor strips .json and appends .<ts>.bk', () => {
+        const p = (0, gatewayBackup_js_1.backupPathFor)('/tmp/gw/route-index.json', '20260607T153000Z');
+        assert.strictEqual(p, path.join('/tmp/gw', 'route-index.20260607T153000Z.bk'));
+    });
+    test('renameToBackup moves an existing file and returns undefined for a missing one', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'bk-'));
+        const src = path.join(dir, 'x.json');
+        fs.writeFileSync(src, '{"a":1}');
+        const dest = await (0, gatewayBackup_js_1.renameToBackup)(src, '20260607T153000Z');
+        assert.strictEqual(dest, path.join(dir, 'x.20260607T153000Z.bk'));
+        assert.ok(!fs.existsSync(src), 'source removed after rename');
+        assert.strictEqual(fs.readFileSync(dest, 'utf8'), '{"a":1}');
+        const missing = await (0, gatewayBackup_js_1.renameToBackup)(path.join(dir, 'nope.json'), '20260607T153000Z');
+        assert.strictEqual(missing, undefined);
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+    // --- route-index clearing ----------------------------------------------------------------
+    test('backupAndClearAgentRouteIndex removes only the target agent and keeps others', async () => {
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1', 'sid-1');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'telegram:dm:u9', 'sid-2');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1', 'sid-keep');
+        const result = await (0, gatewayRouteIndex_js_1.backupAndClearAgentRouteIndex)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.removedRouteKeys.length, 2);
+        assert.deepStrictEqual([...result.removedSessionIds].sort(), ['sid-1', 'sid-2']);
+        assert.ok(result.backupPath && fs.existsSync(result.backupPath), 'backup .bk written');
+        // ide-a forgotten, ide-b preserved in the live file.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1'), undefined);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1'), 'sid-keep');
+        // Backup snapshot still contains the removed routes.
+        const snap = JSON.parse(fs.readFileSync(result.backupPath, 'utf8'));
+        assert.strictEqual(snap.byRoute['ide-a::slack:channel:c1'], 'sid-1');
+    });
+    test('backupAndClearAgentRouteIndex is a no-op when the agent has no routes', async () => {
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1', 'sid-keep');
+        const result = await (0, gatewayRouteIndex_js_1.backupAndClearAgentRouteIndex)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.removedRouteKeys.length, 0);
+        assert.strictEqual(result.backupPath, undefined);
+        assert.strictEqual(listBk(path.dirname((0, gatewayRouteIndex_js_1.getGatewayRouteIndexPath)(workspaceRoot))).length, 0);
+        // Live file untouched.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1'), 'sid-keep');
+    });
+    test('dedupes session ids across multiple routes', async () => {
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1', 'shared');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:thread:t2', 'shared');
+        const result = await (0, gatewayRouteIndex_js_1.backupAndClearAgentRouteIndex)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.removedRouteKeys.length, 2);
+        assert.deepStrictEqual(result.removedSessionIds, ['shared']);
+    });
+    // --- default clearing --------------------------------------------------------------------
+    test('backupAndClearAgentDefault renames the per-agent file and reports the cleared id', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-a', 'default-sid');
+        const result = await (0, gatewayRouteIndex_js_1.backupAndClearAgentDefault)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.hadDefault, true);
+        assert.strictEqual(result.defaultSessionId, 'default-sid');
+        assert.ok(result.backupPath && fs.existsSync(result.backupPath));
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-a'), undefined);
+    });
+    test('backupAndClearAgentDefault is a no-op when no default set', async () => {
+        const result = await (0, gatewayRouteIndex_js_1.backupAndClearAgentDefault)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.hadDefault, false);
+        assert.strictEqual(result.backupPath, undefined);
+    });
+    // --- outbound clearing -------------------------------------------------------------------
+    test('backupAndClearOutboundHandlesForAgent prunes one agent and keeps others', async () => {
+        const storePath = await seedOutbound(workspaceRoot, 'sid-1', 'ide-a', 'slack', 'channel:C1');
+        await (0, outboundHandles_js_1.upsertGatewayOutboundHandle)(storePath, 'ide-b', outboundParams('slack', 'channel:C2'));
+        const result = await (0, outboundHandles_js_1.backupAndClearOutboundHandlesForAgent)(storePath, 'ide-a');
+        assert.strictEqual(result.removed, 1);
+        assert.ok(result.backupPath && fs.existsSync(result.backupPath));
+        // Cache must reflect the prune: ide-a gone, ide-b kept.
+        assert.strictEqual((await (0, outboundHandles_js_1.listGatewayOutboundTargets)(storePath, 'ide-a')).length, 0);
+        assert.strictEqual((await (0, outboundHandles_js_1.listGatewayOutboundTargets)(storePath, 'ide-b')).length, 1);
+        // On-disk live file matches (cache not masking a stale write).
+        const onDisk = JSON.parse(fs.readFileSync(storePath, 'utf8'));
+        assert.strictEqual(onDisk.targetsByAgent['ide-a'], undefined);
+        assert.ok(onDisk.targetsByAgent['ide-b']);
+    });
+    test('backupAndClearOutboundHandlesForAgent is a no-op for an unknown agent', async () => {
+        const storePath = await seedOutbound(workspaceRoot, 'sid-1', 'ide-a', 'slack', 'channel:C1');
+        const result = await (0, outboundHandles_js_1.backupAndClearOutboundHandlesForAgent)(storePath, 'ide-zzz');
+        assert.strictEqual(result.removed, 0);
+        assert.strictEqual(result.backupPath, undefined);
+        assert.strictEqual((await (0, outboundHandles_js_1.listGatewayOutboundTargets)(storePath, 'ide-a')).length, 1);
+    });
+    // --- orchestrator ------------------------------------------------------------------------
+    test('resetAgentMappings clears routes + default + outbound for one agent only', async () => {
+        // ide-a: two routes (sid-1, sid-2) + default (sid-def) + outbound on all three sessions.
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1', 'sid-1');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'telegram:dm:u9', 'sid-2');
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-a', 'sid-def');
+        await seedOutbound(workspaceRoot, 'sid-1', 'ide-a', 'slack', 'channel:C1');
+        await seedOutbound(workspaceRoot, 'sid-2', 'ide-a', 'telegram', 'user:U9');
+        await seedOutbound(workspaceRoot, 'sid-def', 'ide-a', 'slack', 'channel:CDEF');
+        // ide-b: untouched bystander sharing the route-index + a session outbound file.
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1', 'sid-keep');
+        const sharedStore = await seedOutbound(workspaceRoot, 'sid-1', 'ide-b', 'slack', 'channel:CB');
+        const result = await (0, resetMappings_js_1.resetAgentMappings)(workspaceRoot, 'ide-a');
+        assert.strictEqual(result.agentId, 'ide-a');
+        assert.strictEqual(result.routes, 2);
+        assert.strictEqual(result.hadDefault, true);
+        assert.strictEqual(result.sessions, 3, 'three chats had outbound cleared');
+        // ide-a fully forgotten.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1'), undefined);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-a'), undefined);
+        for (const sid of ['sid-1', 'sid-2', 'sid-def']) {
+            const sp = (0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, (0, outboundPaths_js_1.safeGatewaySessionDirId)(sid));
+            assert.strictEqual((await (0, outboundHandles_js_1.listGatewayOutboundTargets)(sp, 'ide-a')).length, 0, `${sid} cleared`);
+        }
+        // ide-b preserved everywhere.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-b', 'slack:channel:c1'), 'sid-keep');
+        assert.strictEqual((await (0, outboundHandles_js_1.listGatewayOutboundTargets)(sharedStore, 'ide-b')).length, 1, 'shared store keeps ide-b');
+    });
+    test('resetAgentMappings is all-zero and writes no backups when nothing is mapped', async () => {
+        const result = await (0, resetMappings_js_1.resetAgentMappings)(workspaceRoot, 'ide-empty');
+        assert.deepStrictEqual(result, { agentId: 'ide-empty', routes: 0, hadDefault: false, sessions: 0 });
+        const gatewayDir = path.dirname((0, gatewayRouteIndex_js_1.getGatewayRouteIndexPath)(workspaceRoot));
+        assert.strictEqual(listBk(gatewayDir).length, 0);
+    });
+    test('resetAgentMappings backups share one timestamp and are recoverable', async () => {
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-a', 'slack:channel:c1', 'sid-1');
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-a', 'sid-def');
+        await seedOutbound(workspaceRoot, 'sid-1', 'ide-a', 'slack', 'channel:C1');
+        await (0, resetMappings_js_1.resetAgentMappings)(workspaceRoot, 'ide-a');
+        const gatewayDir = path.dirname((0, gatewayRouteIndex_js_1.getGatewayRouteIndexPath)(workspaceRoot));
+        const routeBk = listBk(gatewayDir);
+        assert.strictEqual(routeBk.length, 1, 'one route-index .bk');
+        const sessionDir = path.dirname((0, outboundPaths_js_1.getGatewayOutboundFilePath)(workspaceRoot, (0, outboundPaths_js_1.safeGatewaySessionDirId)('sid-1')));
+        assert.strictEqual(listBk(sessionDir).length, 1, 'one outbound .bk');
+        // Recover the route index by renaming the .bk back, then re-read.
+        const liveIndex = (0, gatewayRouteIndex_js_1.getGatewayRouteIndexPath)(workspaceRoot);
+        fs.rmSync(liveIndex, { force: true });
+        fs.renameSync(path.join(gatewayDir, routeBk[0]), liveIndex);
+        (0, gatewayRouteIndex_js_1._resetGatewayRouteIndexLocksForTest)();
+        const restored = await (0, gatewayRouteIndex_js_1.readGatewayRouteIndex)(workspaceRoot);
+        assert.strictEqual(restored.byRoute['ide-a::slack:channel:c1'], 'sid-1');
+    });
+});

package/out/test/gateway-route-index.test.js

@@ -0,0 +1,235 @@
+"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 bridge_js_1 = require("../gateway/bridge.js");
+const gatewayRouteIndex_js_1 = require("../gateway/gatewayRouteIndex.js");
+const gatewaySessionStore_js_1 = require("../gateway/gatewaySessionStore.js");
+suite('Gateway route index', () => {
+    let workspaceRoot;
+    setup(() => {
+        (0, gatewayRouteIndex_js_1._resetGatewayRouteIndexLocksForTest)();
+        workspaceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gateway-route-index-'));
+    });
+    teardown(() => {
+        (0, gatewayRouteIndex_js_1._resetGatewayRouteIndexLocksForTest)();
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    });
+    test('buildRouteIndexKey scopes routes per agent', () => {
+        assert.strictEqual((0, gatewayRouteIndex_js_1.buildRouteIndexKey)('ide-a', 'agent:ide-a:slack:channel:c1'), 'ide-a::agent:ide-a:slack:channel:c1');
+    });
+    test('setRouteSessionMapping persists across reads', async () => {
+        const routeKey = 'agent:ide-myproj:slack:channel:c0123';
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', routeKey, 'chat-uuid-a');
+        const mapped = await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-myproj', routeKey);
+        assert.strictEqual(mapped, 'chat-uuid-a');
+        const index = await (0, gatewayRouteIndex_js_1.readGatewayRouteIndex)(workspaceRoot);
+        assert.strictEqual(index.byRoute[(0, gatewayRouteIndex_js_1.buildRouteIndexKey)('ide-myproj', routeKey)], 'chat-uuid-a');
+    });
+    test('resolveInboundSessionId prefers route index over default', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'default-uuid');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'agent:ide-myproj:slack:channel:c1', 'route-uuid');
+        const resolved = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'agent:ide-myproj:slack:channel:c1',
+        });
+        assert.strictEqual(resolved.sessionId, 'route-uuid');
+        assert.strictEqual(resolved.source, 'routeIndex');
+    });
+    test('resolveInboundSessionId uses default when route unknown', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'default-uuid');
+        const resolved = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'agent:ide-myproj:slack:channel:new',
+        });
+        assert.strictEqual(resolved.sessionId, 'default-uuid');
+        assert.strictEqual(resolved.source, 'defaultPublished');
+    });
+    test('resolveInboundSessionId matches CLI bind label via composite route key', async () => {
+        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
+            version: 1,
+            sessionId: 'chat-bind-1',
+            agentId: 'ide-myproj',
+            packName: 'default',
+            vscodeSessionResource: 'vscode-chat://session/chat-bind-1',
+            published: {
+                mode: 'default',
+                bindLabel: 'fix-login-bug',
+                at: '2026-05-28T12:00:00.000Z',
+            },
+            gatewaySessionKeys: [],
+            updatedAt: '2026-05-28T12:00:00.000Z',
+        });
+        const composite = (0, bridge_js_1.buildIdeSessionRouteKey)('agent:ide-myproj:fix-login-bug', 'pi-uuid');
+        const resolved = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: composite,
+        });
+        assert.strictEqual(resolved.sessionId, 'chat-bind-1');
+        assert.strictEqual(resolved.source, 'bindLabel');
+    });
+    test('defaultPublishedSessionId round-trips', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'pub-uuid');
+        const id = await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj');
+        assert.strictEqual(id, 'pub-uuid');
+    });
+    test('tryClaimDefaultPublishedSessionId is one-shot: first caller wins, default released', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'pub-uuid');
+        const first = await (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj');
+        const second = await (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj');
+        assert.strictEqual(first, 'pub-uuid', 'first claim wins the default');
+        assert.strictEqual(second, undefined, 'default already released — second caller opens its own chat');
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'), undefined);
+    });
+    test('concurrent claims never hand the same default to two channels', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'pub-uuid');
+        const results = await Promise.all([
+            (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'),
+            (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'),
+            (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'),
+        ]);
+        const winners = results.filter((r) => r === 'pub-uuid');
+        assert.strictEqual(winners.length, 1, 'exactly one concurrent caller claims the default');
+    });
+    test('tryClaimDefaultPublishedSessionId returns undefined when no default set', async () => {
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.tryClaimDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'), undefined);
+    });
+    test('channel route key skips bind-label scan and falls through to defaultPublished', async () => {
+        // Populate a session with a bind label that could accidentally match
+        await (0, gatewaySessionStore_js_1.writeGatewaySessionRecord)(workspaceRoot, {
+            version: 1,
+            sessionId: 'chat-should-not-match',
+            agentId: 'ide-myproj',
+            packName: 'default',
+            vscodeSessionResource: 'vscode://session/1',
+            published: { mode: 'default', bindLabel: 'slack', at: new Date().toISOString() },
+            gatewaySessionKeys: [],
+            updatedAt: new Date().toISOString(),
+        });
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'default-session');
+        // A Slack channel key must not match via bind label — it goes straight to defaultPublished
+        const resolved = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'agent:ide-myproj:slack:channel:C0B1SMMJCQ0',
+        });
+        assert.strictEqual(resolved.sessionId, 'default-session');
+        assert.strictEqual(resolved.source, 'defaultPublished');
+    });
+    test('peer route mapping does not imply a new default when default unchanged', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'session-a');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'telegram:dm:7550356539', 'session-b');
+        const defaultId = await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj');
+        assert.strictEqual(defaultId, 'session-a');
+        const peerMapped = await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'telegram:dm:7550356539');
+        assert.strictEqual(peerMapped, 'session-b');
+    });
+    test('unmatched composite IDE key skips default and creates new session', async () => {
+        // Publish a default agent session
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'default-uuid');
+        // Inbound arrives with composite IDE key that doesn't match any bind label
+        const unmatchedComposite = (0, bridge_js_1.buildIdeSessionRouteKey)('agent:ide-myproj:nonexistent', 'pi-uuid');
+        const resolved = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: unmatchedComposite,
+        });
+        // Should NOT reuse the default — composite keys get isolated
+        assert.strictEqual(resolved.sessionId, undefined);
+        assert.strictEqual(resolved.source, 'new');
+    });
+    test('clearDefaultPublishedSessionId only clears when it matches expected (one-shot consume)', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'chat-x');
+        // A concurrent publish moved the default to a different chat — stale clear must be a no-op.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.clearDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'chat-y'), false);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'), 'chat-x');
+        // Matching clear releases the default so the next unmatched route opens a fresh chat.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.clearDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'chat-x'), true);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj'), undefined);
+    });
+    test('one-shot default: first unmatched route resolves to default, next is a new session', async () => {
+        await (0, gatewayRouteIndex_js_1.setDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'chat-x');
+        // First unmatched channel route lands on the default chat.
+        const first = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'slack:channel:c1',
+        });
+        assert.strictEqual(first.sessionId, 'chat-x');
+        assert.strictEqual(first.source, 'defaultPublished');
+        // Simulate the service persisting the binding + consuming the one-shot default.
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', first.persistRouteKey, 'chat-x');
+        await (0, gatewayRouteIndex_js_1.clearDefaultPublishedSessionId)(workspaceRoot, 'ide-myproj', 'chat-x');
+        // The same route now resolves straight from the index.
+        const repeat = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'slack:channel:c1',
+        });
+        assert.strictEqual(repeat.sessionId, 'chat-x');
+        assert.strictEqual(repeat.source, 'routeIndex');
+        // A different unmatched route no longer piles onto chat-x — caller creates a new session.
+        const second = await (0, gatewayRouteIndex_js_1.resolveInboundSessionId)({
+            workspaceRoot,
+            agentId: 'ide-myproj',
+            routeKey: 'slack:channel:c2',
+        });
+        assert.strictEqual(second.sessionId, undefined);
+        assert.strictEqual(second.source, 'new');
+    });
+    test('removeRouteSessionMappingsForSession removes only that session\'s routes', async () => {
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'slack:channel:c1', 'chat-x');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'telegram:dm:42', 'chat-x');
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'slack:channel:c9', 'chat-y');
+        // Same route key under a different agent must be untouched.
+        await (0, gatewayRouteIndex_js_1.setRouteSessionMapping)(workspaceRoot, 'other-agent', 'slack:channel:c1', 'chat-x');
+        const removed = await (0, gatewayRouteIndex_js_1.removeRouteSessionMappingsForSession)(workspaceRoot, 'ide-myproj', 'chat-x');
+        assert.deepStrictEqual(removed.sort(), ['slack:channel:c1', 'telegram:dm:42']);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'slack:channel:c1'), undefined);
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'telegram:dm:42'), undefined);
+        // Other session and other agent mappings survive.
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'ide-myproj', 'slack:channel:c9'), 'chat-y');
+        assert.strictEqual(await (0, gatewayRouteIndex_js_1.getRouteSessionMapping)(workspaceRoot, 'other-agent', 'slack:channel:c1'), 'chat-x');
+    });
+});

package/out/test/gateway-session-routing.test.js

@@ -0,0 +1,47 @@
+"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 bridge_js_1 = require("../gateway/bridge.js");
+suite('Gateway session routing', () => {
+    test('looksLikeGatewayChannelRouteKey detects Slack channel keys', () => {
+        assert.strictEqual((0, bridge_js_1.looksLikeGatewayChannelRouteKey)('agent:ide-ws-data-analyst:slack:channel:c0b1smmjcq0'), true);
+        assert.strictEqual((0, bridge_js_1.looksLikeGatewayChannelRouteKey)('agent:data-analyst:slack:dm:u0b1218aefn'), true);
+        assert.strictEqual((0, bridge_js_1.looksLikeGatewayChannelRouteKey)('agent:data-analyst:main'), false);
+    });
+});