@agenthippo-ai/agenthippo 0.1.0

package/out/gateway/gatewayRouteIndex.js

@@ -0,0 +1,371 @@
+"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 });
+exports.GATEWAY_ROUTE_INDEX_FILENAME = void 0;
+exports._resetGatewayRouteIndexLocksForTest = _resetGatewayRouteIndexLocksForTest;
+exports.buildRouteIndexKey = buildRouteIndexKey;
+exports.getGatewayRouteIndexPath = getGatewayRouteIndexPath;
+exports.getAgentGatewayStatePath = getAgentGatewayStatePath;
+exports.readGatewayRouteIndex = readGatewayRouteIndex;
+exports.readAgentGatewayState = readAgentGatewayState;
+exports.setDefaultPublishedSessionId = setDefaultPublishedSessionId;
+exports.getDefaultPublishedSessionId = getDefaultPublishedSessionId;
+exports.clearDefaultPublishedSessionId = clearDefaultPublishedSessionId;
+exports.tryClaimDefaultPublishedSessionId = tryClaimDefaultPublishedSessionId;
+exports.setRouteSessionMapping = setRouteSessionMapping;
+exports.getRouteSessionMapping = getRouteSessionMapping;
+exports.removeRouteSessionMappingsForSession = removeRouteSessionMappingsForSession;
+exports.backupAndClearAgentRouteIndex = backupAndClearAgentRouteIndex;
+exports.backupAndClearAgentDefault = backupAndClearAgentDefault;
+exports.resolveInboundSessionId = resolveInboundSessionId;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const branding_js_1 = require("../branding.js");
+const gatewayBackup_js_1 = require("./gatewayBackup.js");
+const bridge_js_1 = require("./bridge.js");
+const gatewaySessionStore_js_1 = require("./gatewaySessionStore.js");
+const ROUTE_INDEX_VERSION = 1;
+const AGENT_STATE_VERSION = 1;
+exports.GATEWAY_ROUTE_INDEX_FILENAME = 'route-index.json';
+const indexMutationQueues = new Map();
+function withMutationLock(key, fn) {
+    const prev = indexMutationQueues.get(key) ?? Promise.resolve();
+    const run = prev.then(() => fn());
+    indexMutationQueues.set(key, run.catch(() => undefined));
+    return run;
+}
+/** @internal */
+function _resetGatewayRouteIndexLocksForTest() {
+    indexMutationQueues.clear();
+}
+function buildRouteIndexKey(agentId, routeKey) {
+    return `${agentId}::${routeKey.trim()}`;
+}
+function getGatewayRouteIndexPath(workspaceRoot) {
+    return path.join(workspaceRoot, branding_js_1.AGENTIDE_DIR_NAME, 'gateway', exports.GATEWAY_ROUTE_INDEX_FILENAME);
+}
+function getAgentGatewayStatePath(workspaceRoot, agentId) {
+    const safeAgent = agentId.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').slice(0, 120) || 'agent';
+    return path.join(workspaceRoot, branding_js_1.AGENTIDE_DIR_NAME, 'gateway', 'agents', `${safeAgent}.json`);
+}
+function emptyRouteIndex() {
+    return {
+        version: ROUTE_INDEX_VERSION,
+        byRoute: {},
+        updatedAt: new Date().toISOString(),
+    };
+}
+async function readGatewayRouteIndex(workspaceRoot) {
+    const filePath = getGatewayRouteIndexPath(workspaceRoot);
+    try {
+        const raw = await fs_1.promises.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== ROUTE_INDEX_VERSION || !parsed.byRoute) {
+            return emptyRouteIndex();
+        }
+        return parsed;
+    }
+    catch (err) {
+        const code = err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+        if (code === 'ENOENT') {
+            return emptyRouteIndex();
+        }
+        throw err;
+    }
+}
+async function writeGatewayRouteIndex(workspaceRoot, index) {
+    const filePath = getGatewayRouteIndexPath(workspaceRoot);
+    await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const next = {
+        ...index,
+        version: ROUTE_INDEX_VERSION,
+        updatedAt: new Date().toISOString(),
+    };
+    await fs_1.promises.writeFile(filePath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+}
+async function readAgentGatewayState(workspaceRoot, agentId) {
+    const filePath = getAgentGatewayStatePath(workspaceRoot, agentId);
+    try {
+        const raw = await fs_1.promises.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== AGENT_STATE_VERSION || parsed.agentId !== agentId) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch (err) {
+        const code = err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+}
+async function setDefaultPublishedSessionId(workspaceRoot, agentId, sessionId) {
+    const filePath = getAgentGatewayStatePath(workspaceRoot, agentId);
+    // Locked read-modify-write so concurrent default-session mutations (clear/claim) don't clobber
+    // each other; shares the file-path lock key with clear/tryClaim.
+    await withMutationLock(filePath, async () => {
+        await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+        const existing = (await readAgentGatewayState(workspaceRoot, agentId)) ?? {
+            version: AGENT_STATE_VERSION,
+            agentId,
+            updatedAt: new Date().toISOString(),
+        };
+        await fs_1.promises.writeFile(filePath, `${JSON.stringify({
+            ...existing,
+            version: AGENT_STATE_VERSION,
+            agentId,
+            defaultPublishedSessionId: sessionId,
+            updatedAt: new Date().toISOString(),
+        }, null, 2)}\n`, 'utf8');
+    });
+}
+async function getDefaultPublishedSessionId(workspaceRoot, agentId) {
+    const state = await readAgentGatewayState(workspaceRoot, agentId);
+    return state?.defaultPublishedSessionId?.trim() || undefined;
+}
+/**
+ * Release the agent's default-published session.
+ * The default is a one-shot claim: once an unmatched inbound route binds to it, it is cleared so
+ * the next new route opens a fresh chat instead of piling onto the same one.
+ * Pass `expectedSessionId` to only clear when the default still points at that session (avoids
+ * clobbering a newer default set by a concurrent publish). Returns true if a value was cleared.
+ */
+async function clearDefaultPublishedSessionId(workspaceRoot, agentId, expectedSessionId) {
+    const filePath = getAgentGatewayStatePath(workspaceRoot, agentId);
+    // Locked read-modify-write: the `expectedSessionId` compare must be atomic with the write,
+    // otherwise a concurrent publish/claim on the same agent file can be clobbered. Shares the
+    // file-path lock key with tryClaim/set so all default-session mutations serialize.
+    return withMutationLock(filePath, async () => {
+        const existing = await readAgentGatewayState(workspaceRoot, agentId);
+        const current = existing?.defaultPublishedSessionId?.trim();
+        if (!current) {
+            return false;
+        }
+        if (expectedSessionId && current !== expectedSessionId.trim()) {
+            return false;
+        }
+        await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs_1.promises.writeFile(filePath, `${JSON.stringify({
+            version: AGENT_STATE_VERSION,
+            agentId,
+            updatedAt: new Date().toISOString(),
+        }, null, 2)}\n`, 'utf8');
+        return true;
+    });
+}
+/**
+ * Atomically claim the agent's default published session: return its id and release it in the
+ * same locked step, so only the *first* unmatched inbound can bind to it. Concurrent or bursted
+ * inbound from other channels (e.g. a Slack backlog flushed on reconnect) get `undefined` and must
+ * open their own per-channel chat instead of all collapsing onto the default. Returns undefined
+ * when no default is set.
+ */
+async function tryClaimDefaultPublishedSessionId(workspaceRoot, agentId) {
+    const filePath = getAgentGatewayStatePath(workspaceRoot, agentId);
+    return withMutationLock(filePath, async () => {
+        const existing = await readAgentGatewayState(workspaceRoot, agentId);
+        const current = existing?.defaultPublishedSessionId?.trim();
+        if (!current) {
+            return undefined;
+        }
+        await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+        await fs_1.promises.writeFile(filePath, `${JSON.stringify({
+            version: AGENT_STATE_VERSION,
+            agentId,
+            updatedAt: new Date().toISOString(),
+        }, null, 2)}\n`, 'utf8');
+        return current;
+    });
+}
+async function setRouteSessionMapping(workspaceRoot, agentId, routeKey, sessionId) {
+    const rk = routeKey.trim();
+    const sid = sessionId.trim();
+    if (!rk || !sid) {
+        return;
+    }
+    const lockKey = getGatewayRouteIndexPath(workspaceRoot);
+    await withMutationLock(lockKey, async () => {
+        const index = await readGatewayRouteIndex(workspaceRoot);
+        index.byRoute[buildRouteIndexKey(agentId, rk)] = sid;
+        await writeGatewayRouteIndex(workspaceRoot, index);
+    });
+}
+async function getRouteSessionMapping(workspaceRoot, agentId, routeKey) {
+    const rk = routeKey?.trim();
+    if (!rk) {
+        return undefined;
+    }
+    const index = await readGatewayRouteIndex(workspaceRoot);
+    return index.byRoute[buildRouteIndexKey(agentId, rk)];
+}
+/** Remove every route → session mapping that points at `sessionId` for this agent. Returns the removed route keys (base, agent prefix stripped). */
+async function removeRouteSessionMappingsForSession(workspaceRoot, agentId, sessionId) {
+    const sid = sessionId.trim();
+    if (!sid) {
+        return [];
+    }
+    const prefix = `${agentId}::`;
+    const lockKey = getGatewayRouteIndexPath(workspaceRoot);
+    return withMutationLock(lockKey, async () => {
+        const index = await readGatewayRouteIndex(workspaceRoot);
+        const removed = [];
+        for (const [key, mappedSid] of Object.entries(index.byRoute)) {
+            if (mappedSid === sid && key.startsWith(prefix)) {
+                removed.push(key.slice(prefix.length));
+                delete index.byRoute[key];
+            }
+        }
+        if (removed.length > 0) {
+            await writeGatewayRouteIndex(workspaceRoot, index);
+        }
+        return removed;
+    });
+}
+/**
+ * Back up `route-index.json` to a timestamped `.bk` sibling, then rewrite it with this agent's
+ * `${agentId}::*` entries removed (other agents preserved). No-op (and no backup) when the agent
+ * has no entries. Returns the removed route keys and the distinct session ids they pointed at so
+ * callers can clear the matching per-session outbound stores.
+ */
+async function backupAndClearAgentRouteIndex(workspaceRoot, agentId, ts = (0, gatewayBackup_js_1.backupTimestamp)()) {
+    const filePath = getGatewayRouteIndexPath(workspaceRoot);
+    const prefix = `${agentId}::`;
+    return withMutationLock(filePath, async () => {
+        const index = await readGatewayRouteIndex(workspaceRoot);
+        const removedRouteKeys = [];
+        const removedSessionIds = new Set();
+        for (const [key, sid] of Object.entries(index.byRoute)) {
+            if (key.startsWith(prefix)) {
+                removedRouteKeys.push(key.slice(prefix.length));
+                if (sid) {
+                    removedSessionIds.add(sid);
+                }
+                delete index.byRoute[key];
+            }
+        }
+        if (removedRouteKeys.length === 0) {
+            return { removedRouteKeys, removedSessionIds: [] };
+        }
+        // Snapshot the whole (multi-agent) file, then rewrite with the remaining agents' routes.
+        const backupPath = await (0, gatewayBackup_js_1.renameToBackup)(filePath, ts);
+        await writeGatewayRouteIndex(workspaceRoot, index);
+        return { removedRouteKeys, removedSessionIds: [...removedSessionIds], backupPath };
+    });
+}
+/**
+ * Back up `agents/<agentId>.json` to a `.bk` sibling (pure rename — the file holds only this
+ * agent's state). No-op when the file is absent or carries no default session.
+ */
+async function backupAndClearAgentDefault(workspaceRoot, agentId, ts = (0, gatewayBackup_js_1.backupTimestamp)()) {
+    const filePath = getAgentGatewayStatePath(workspaceRoot, agentId);
+    // Shares the file-path lock key with set/clear/claim so default-session mutations serialize.
+    return withMutationLock(filePath, async () => {
+        const state = await readAgentGatewayState(workspaceRoot, agentId);
+        const defaultSessionId = state?.defaultPublishedSessionId?.trim() || undefined;
+        if (!defaultSessionId) {
+            return { hadDefault: false };
+        }
+        const backupPath = await (0, gatewayBackup_js_1.renameToBackup)(filePath, ts);
+        return { hadDefault: true, defaultSessionId, backupPath };
+    });
+}
+/**
+ * Resolve which AgentHippo session id should handle an inbound gateway message.
+ * Returns `sessionId: undefined` with `source: 'new'` when the caller should create a chat.
+ */
+async function resolveInboundSessionId(input) {
+    const { workspaceRoot, agentId } = input;
+    const routeKey = input.routeKey?.trim();
+    const gatewaySessionKey = input.gatewaySessionKey?.trim() || routeKey;
+    const persistRouteKey = gatewaySessionKey || routeKey;
+    // 1. Route index (learned or peer-bound at publish)
+    if (routeKey) {
+        const fromIndex = await getRouteSessionMapping(workspaceRoot, agentId, routeKey);
+        if (fromIndex) {
+            return { sessionId: fromIndex, source: 'routeIndex', persistRouteKey };
+        }
+    }
+    if (gatewaySessionKey && gatewaySessionKey !== routeKey) {
+        const fromIndex = await getRouteSessionMapping(workspaceRoot, agentId, gatewaySessionKey);
+        if (fromIndex) {
+            return { sessionId: fromIndex, source: 'routeIndex', persistRouteKey: gatewaySessionKey };
+        }
+    }
+    // 2. CLI bind label — composite `::sid:` or `agent:<id>:<label>` tail.
+    // Channel/DM/thread route keys are peer identifiers, never CLI bind labels — skip the scan.
+    const isChannelKey = (0, bridge_js_1.looksLikeGatewayChannelRouteKey)(routeKey);
+    if (!isChannelKey) {
+        const compositeLabel = routeKey ? (0, bridge_js_1.parseIdeThreadIdFromCompositeRouteKey)(routeKey) : undefined;
+        if (compositeLabel) {
+            const byLabel = await (0, gatewaySessionStore_js_1.findPublishedSessionIdByBindLabel)(workspaceRoot, agentId, compositeLabel);
+            if (byLabel) {
+                return { sessionId: byLabel, source: 'bindLabel', persistRouteKey };
+            }
+        }
+        const gatewayBaseKey = routeKey && (0, bridge_js_1.isIdeThreadCompositeRouteKey)(routeKey)
+            ? routeKey.slice(0, routeKey.lastIndexOf('::sid:'))
+            : routeKey;
+        const cliLabelFromGatewayKey = gatewayBaseKey
+            ? (0, bridge_js_1.extractRouteLabelFromGatewaySessionKey)(gatewayBaseKey)
+            : undefined;
+        if (cliLabelFromGatewayKey) {
+            const byGatewayLabel = await (0, gatewaySessionStore_js_1.findPublishedSessionIdByBindLabel)(workspaceRoot, agentId, cliLabelFromGatewayKey);
+            if (byGatewayLabel) {
+                return { sessionId: byGatewayLabel, source: 'bindLabel', persistRouteKey };
+            }
+        }
+        if (input.gatewayWireSessionId?.trim()) {
+            const byWire = await (0, gatewaySessionStore_js_1.findPublishedSessionIdByBindLabel)(workspaceRoot, agentId, input.gatewayWireSessionId.trim());
+            if (byWire) {
+                return { sessionId: byWire, source: 'bindLabel', persistRouteKey };
+            }
+        }
+        // Composite CLI thread with no bind-label hit — isolate (do not fall through to default).
+        if (routeKey && (0, bridge_js_1.isIdeThreadCompositeRouteKey)(routeKey)) {
+            return { source: 'new', persistRouteKey };
+        }
+    }
+    // 3. Default published session for this agent
+    const defaultId = await getDefaultPublishedSessionId(workspaceRoot, agentId);
+    if (defaultId) {
+        return { sessionId: defaultId, source: 'defaultPublished', persistRouteKey };
+    }
+    return { source: 'new', persistRouteKey };
+}

package/out/gateway/gatewaySessionStore.js

@@ -0,0 +1,243 @@
+"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 });
+exports.GATEWAY_SESSION_FILENAME = void 0;
+exports.normalizeInboundBindLabel = normalizeInboundBindLabel;
+exports.inboundBindLabelsMatch = inboundBindLabelsMatch;
+exports.shouldUpdateAgentDefaultOnGatewayPublish = shouldUpdateAgentDefaultOnGatewayPublish;
+exports.mergeGatewaySessionKeyList = mergeGatewaySessionKeyList;
+exports.getGatewaySessionFilePath = getGatewaySessionFilePath;
+exports.readGatewaySessionRecord = readGatewaySessionRecord;
+exports.writeGatewaySessionRecord = writeGatewaySessionRecord;
+exports.isGatewaySessionRecordOrphaned = isGatewaySessionRecordOrphaned;
+exports.deleteGatewaySessionRecord = deleteGatewaySessionRecord;
+exports.detachGatewaySessionRoutes = detachGatewaySessionRoutes;
+exports.clearGatewaySessionPublishedDefault = clearGatewaySessionPublishedDefault;
+exports.appendGatewaySessionKey = appendGatewaySessionKey;
+exports.updateGatewaySessionResource = updateGatewaySessionResource;
+exports.findPublishedSessionIdByBindLabel = findPublishedSessionIdByBindLabel;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const branding_js_1 = require("../branding.js");
+const outboundPaths_js_1 = require("./outboundPaths.js");
+exports.GATEWAY_SESSION_FILENAME = 'gateway-session.json';
+const RECORD_VERSION = 1;
+/** Map chat title / CLI `--session-id` to one comparable token. */
+function normalizeInboundBindLabel(raw) {
+    let s = raw.trim().toLowerCase().replace(/\s+/g, '-');
+    s = s.replace(/-+/g, '-');
+    s = s.replace(/^-+|-+$/g, '');
+    return s;
+}
+function inboundBindLabelsMatch(a, b) {
+    return normalizeInboundBindLabel(a) === normalizeInboundBindLabel(b);
+}
+/** Peer-only publish updates route index but must not replace the agent default session. */
+function shouldUpdateAgentDefaultOnGatewayPublish(mode) {
+    return mode === 'default';
+}
+/** Union of prior and new gateway session keys (idempotent republish / inbound learn). */
+function mergeGatewaySessionKeyList(existing, ...candidates) {
+    const keys = new Set(existing.map((k) => k.trim()).filter((k) => k.length > 0));
+    for (const candidate of candidates) {
+        const trimmed = candidate?.trim();
+        if (trimmed) {
+            keys.add(trimmed);
+        }
+    }
+    return [...keys];
+}
+function getGatewaySessionFilePath(workspaceRoot, sessionId) {
+    const dirId = (0, outboundPaths_js_1.safeGatewaySessionDirId)(sessionId);
+    return path.join(workspaceRoot, branding_js_1.AGENTIDE_DIR_NAME, 'sessions', dirId, exports.GATEWAY_SESSION_FILENAME);
+}
+async function readGatewaySessionRecord(workspaceRoot, sessionId) {
+    const filePath = getGatewaySessionFilePath(workspaceRoot, sessionId);
+    try {
+        const raw = await fs_1.promises.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version !== RECORD_VERSION || !parsed.sessionId) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch (err) {
+        const code = err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+}
+async function writeGatewaySessionRecord(workspaceRoot, record) {
+    const filePath = getGatewaySessionFilePath(workspaceRoot, record.sessionId);
+    await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+    const next = {
+        ...record,
+        version: RECORD_VERSION,
+        updatedAt: new Date().toISOString(),
+    };
+    await fs_1.promises.writeFile(filePath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+}
+/** True when a record holds no remaining gateway binding (safe to delete if also not the agent default). */
+function isGatewaySessionRecordOrphaned(record) {
+    return record.gatewaySessionKeys.length === 0 && !record.published;
+}
+/** Delete a chat's gateway binding record. The chat itself (VS Code session storage) is untouched. */
+async function deleteGatewaySessionRecord(workspaceRoot, sessionId) {
+    const filePath = getGatewaySessionFilePath(workspaceRoot, sessionId);
+    try {
+        await fs_1.promises.rm(filePath, { force: true });
+    }
+    catch {
+        // best-effort cleanup
+    }
+}
+/**
+ * Detach route keys from a chat after they were reassigned to another chat.
+ * Removes the keys from `gatewaySessionKeys` and clears `published` when its peer route was among
+ * them. Returns the updated record (or undefined if the chat had no record).
+ */
+async function detachGatewaySessionRoutes(workspaceRoot, sessionId, routeKeys) {
+    const existing = await readGatewaySessionRecord(workspaceRoot, sessionId);
+    if (!existing) {
+        return undefined;
+    }
+    const targets = new Set(routeKeys.map((k) => k.trim()).filter((k) => k.length > 0));
+    if (targets.size === 0) {
+        return existing;
+    }
+    const gatewaySessionKeys = existing.gatewaySessionKeys.filter((k) => !targets.has(k.trim()));
+    const published = existing.published?.mode === 'peer' &&
+        existing.published.peerRoute &&
+        targets.has(existing.published.peerRoute.trim())
+        ? undefined
+        : existing.published;
+    if (gatewaySessionKeys.length === existing.gatewaySessionKeys.length && published === existing.published) {
+        return existing;
+    }
+    const next = { ...existing, gatewaySessionKeys, published };
+    await writeGatewaySessionRecord(workspaceRoot, next);
+    return next;
+}
+/**
+ * Clear a chat's `published` binding when it was the agent default that got reassigned away.
+ * Returns the updated record (or undefined if the chat had no record).
+ */
+async function clearGatewaySessionPublishedDefault(workspaceRoot, sessionId) {
+    const existing = await readGatewaySessionRecord(workspaceRoot, sessionId);
+    if (!existing) {
+        return undefined;
+    }
+    if (existing.published?.mode !== 'default') {
+        return existing;
+    }
+    const next = { ...existing, published: undefined };
+    await writeGatewaySessionRecord(workspaceRoot, next);
+    return next;
+}
+async function appendGatewaySessionKey(workspaceRoot, sessionId, gatewaySessionKey) {
+    const key = gatewaySessionKey.trim();
+    if (!key) {
+        return;
+    }
+    const existing = await readGatewaySessionRecord(workspaceRoot, sessionId);
+    if (!existing) {
+        return;
+    }
+    if (existing.gatewaySessionKeys.includes(key)) {
+        return;
+    }
+    await writeGatewaySessionRecord(workspaceRoot, {
+        ...existing,
+        gatewaySessionKeys: [...existing.gatewaySessionKeys, key],
+    });
+}
+async function updateGatewaySessionResource(workspaceRoot, sessionId, vscodeSessionResource, chatMode) {
+    const existing = await readGatewaySessionRecord(workspaceRoot, sessionId);
+    if (!existing) {
+        return;
+    }
+    await writeGatewaySessionRecord(workspaceRoot, {
+        ...existing,
+        vscodeSessionResource,
+        chatMode: chatMode ?? existing.chatMode,
+    });
+}
+async function findPublishedSessionIdByBindLabel(workspaceRoot, agentId, label) {
+    const normalized = normalizeInboundBindLabel(label);
+    if (!normalized) {
+        return undefined;
+    }
+    const sessionsRoot = path.join(workspaceRoot, branding_js_1.AGENTIDE_DIR_NAME, 'sessions');
+    let entries;
+    try {
+        entries = await fs_1.promises.readdir(sessionsRoot);
+    }
+    catch (err) {
+        const code = err && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw err;
+    }
+    for (const dirName of entries) {
+        const filePath = path.join(sessionsRoot, dirName, exports.GATEWAY_SESSION_FILENAME);
+        let raw;
+        try {
+            raw = await fs_1.promises.readFile(filePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (parsed.agentId !== agentId || !parsed.published?.bindLabel) {
+            continue;
+        }
+        if (inboundBindLabelsMatch(parsed.published.bindLabel, normalized)) {
+            return parsed.sessionId;
+        }
+    }
+    return undefined;
+}

package/out/gateway/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_ANYWHERE_LABEL = exports.detectGateway = exports.GatewayLifecycleManager = exports.GatewayService = exports.PROTOCOL_VERSION = exports.GATEWAY_CLIENT_MODES = exports.GATEWAY_CLIENT_IDS = exports.GATEWAY_CLIENT_CAPS = exports.DEFAULT_GATEWAY_OPERATOR_SCOPES = exports.createAgentIDEGatewayClient = exports.GatewayClient = exports.createGatewayBridge = exports.GatewayBridge = void 0;
+/* eslint-disable local/code-no-unexternalized-strings */
+/**
+ * OpenClaw Gateway Integration
+ *
+ * This module provides integration with OpenClaw Gateway, allowing
+ * AgentIDE agents to receive messages from messaging channels.
+ */
+var bridge_js_1 = require("./bridge.js");
+Object.defineProperty(exports, "GatewayBridge", { enumerable: true, get: function () { return bridge_js_1.GatewayBridge; } });
+Object.defineProperty(exports, "createGatewayBridge", { enumerable: true, get: function () { return bridge_js_1.createGatewayBridge; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "GatewayClient", { enumerable: true, get: function () { return client_js_1.GatewayClient; } });
+Object.defineProperty(exports, "createAgentIDEGatewayClient", { enumerable: true, get: function () { return client_js_1.createAgentIDEGatewayClient; } });
+var protocol_js_1 = require("./protocol.js");
+Object.defineProperty(exports, "DEFAULT_GATEWAY_OPERATOR_SCOPES", { enumerable: true, get: function () { return protocol_js_1.DEFAULT_GATEWAY_OPERATOR_SCOPES; } });
+Object.defineProperty(exports, "GATEWAY_CLIENT_CAPS", { enumerable: true, get: function () { return protocol_js_1.GATEWAY_CLIENT_CAPS; } });
+Object.defineProperty(exports, "GATEWAY_CLIENT_IDS", { enumerable: true, get: function () { return protocol_js_1.GATEWAY_CLIENT_IDS; } });
+Object.defineProperty(exports, "GATEWAY_CLIENT_MODES", { enumerable: true, get: function () { return protocol_js_1.GATEWAY_CLIENT_MODES; } });
+Object.defineProperty(exports, "PROTOCOL_VERSION", { enumerable: true, get: function () { return protocol_js_1.PROTOCOL_VERSION; } });
+var service_js_1 = require("./service.js");
+Object.defineProperty(exports, "GatewayService", { enumerable: true, get: function () { return service_js_1.GatewayService; } });
+var lifecycle_js_1 = require("./lifecycle.js");
+Object.defineProperty(exports, "GatewayLifecycleManager", { enumerable: true, get: function () { return lifecycle_js_1.GatewayLifecycleManager; } });
+Object.defineProperty(exports, "detectGateway", { enumerable: true, get: function () { return lifecycle_js_1.detectGateway; } });
+Object.defineProperty(exports, "AGENT_ANYWHERE_LABEL", { enumerable: true, get: function () { return lifecycle_js_1.AGENT_ANYWHERE_LABEL; } });