@deadragdoll/tellymcp 0.0.10 → 0.0.11

package/dist/services/features/telegram-mcp/src/features/collaboration/model/localCollaborationBackend.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCollaborationBackend = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const ids_1 = require("../../../shared/lib/ids/ids");
-const client_1 = require("../../../shared/integrations/tmux/client");
+const xchangeRecordHints_1 = require("../../../shared/lib/xchangeRecordHints");
+const client_1 = require("../../../shared/integrations/terminal/client");
+const sqliteRecordStore_1 = require("../../../shared/integrations/xchange/sqliteRecordStore");
 function slugify(input) {
     return input
         .trim()
@@ -49,7 +50,6 @@ const SOURCE_ARTIFACT_EXTENSIONS = new Set([
     ".xml",
     ".zsh",
 ]);
-const PARTNER_INDEX_FILE_NAME = "SHARED_INDEX.md";
 function trimOptional(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
@@ -78,35 +78,6 @@ function renderYamlArray(values) {
     }
     return `\n${values.map((value) => `  - ${JSON.stringify(value)}`).join("\n")}`;
 }
-function buildPartnerInboxText(input) {
-    const kindTitle = input.kind === "question"
-        ? "Partner question received."
-        : input.kind === "reply"
-            ? "Partner reply received."
-            : input.kind === "request"
-                ? "Partner request received."
-                : input.kind === "handoff"
-                    ? "Partner handoff received."
-                    : "Partner update received.";
-    return [
-        kindTitle,
-        `From: ${input.fromLabel}`,
-        `Summary: ${input.summary}`,
-        "",
-        `Immediate action: read ${PARTNER_INDEX_FILE_NAME} and then open the note below.`,
-        `Note: ${input.notePath}`,
-        ...(input.copiedArtifacts.length > 0
-            ? ["", "Artifacts:", ...input.copiedArtifacts.map((item) => `- ${item}`)]
-            : []),
-        ...(input.requiresReply
-            ? [
-                "",
-                "Reply through send_partner_note after you finish the requested work.",
-                "The task is not complete until send_partner_note succeeds.",
-            ]
-            : []),
-    ].join("\n");
-}
 function buildNoteContent(input) {
     const lines = ["---"];
     lines.push(`kind: ${JSON.stringify(input.kind)}`);
@@ -129,38 +100,26 @@ function buildNoteContent(input) {
         lines.push("", "# Expected Reply", input.expectedReply.trim());
     }
     if (input.requiresReply) {
-        lines.push("", "# Action Required", "You must send a reply via send_partner_note.", "Your task is not complete until send_partner_note succeeds.", "Do not stop after local analysis or a chat explanation.", "Use the current partner route for the reply.", "Only after the tool succeeds may you say that the reply was sent.", "", "# Reply Tool Call Example", "send_partner_note(", `  session_id=${JSON.stringify(input.targetSessionId)},`, `  kind=${JSON.stringify("reply")},`, "  summary=\"Короткий итог\",", "  message=\"Подробный ответ\"", ")");
+        lines.push("", "# Action Required", "You must send a reply via send_partner_note.", "Do not stop after reading, listing files, or explaining what you found.", "Your task is not complete until send_partner_note succeeds.", "Do not stop after local analysis or a chat explanation.", "Only after send_partner_note succeeds may you mark the record as read or say the work is done.", "Use the current partner route for the reply.", "Only after the tool succeeds may you say that the reply was sent.", "", "# Reply Tool Call Example", "send_partner_note(", `  session_id=${JSON.stringify(input.targetSessionId)},`, `  kind=${JSON.stringify("reply")},`, "  summary=\"Короткий итог\",", "  message=\"Подробный ответ\"", ")");
     }
     if (input.copiedArtifacts.length > 0) {
         lines.push("", "# Artifacts", ...input.copiedArtifacts.map((artifact) => `- ${artifact}`));
     }
     return `${lines.join("\n")}\n`;
 }
-function buildShareIndexLine(input) {
-    return [
-        "-",
-        `[${input.createdAt}]`,
-        `${input.sourceLabel} → ${input.targetLabel}`,
-        `| ${input.kind} |`,
-        `${input.summary}`,
-        `| \`${input.relativeNotePath}\``,
-    ].join(" ");
-}
 class LocalCollaborationBackend {
     config;
     sessionStore;
     bindingStore;
-    inboxStore;
     xchangeFileMetaStore;
     objectStore;
     telegramTransport;
     logger;
     textEncoder = new TextEncoder();
-    constructor(config, sessionStore, bindingStore, inboxStore, xchangeFileMetaStore, objectStore, telegramTransport, logger) {
+    constructor(config, sessionStore, bindingStore, xchangeFileMetaStore, objectStore, telegramTransport, logger) {
         this.config = config;
         this.sessionStore = sessionStore;
         this.bindingStore = bindingStore;
-        this.inboxStore = inboxStore;
         this.xchangeFileMetaStore = xchangeFileMetaStore;
         this.objectStore = objectStore;
         this.telegramTransport = telegramTransport;
@@ -169,11 +128,11 @@ class LocalCollaborationBackend {
     async sendPartnerNote(input, resolved) {
         const sourceSession = await this.sessionStore.getSession(resolved.sessionId);
         if (!sourceSession) {
-            throw new Error(`Session ${resolved.sessionId} was not found. Pair the session before collaborating.`);
+            throw new Error(`Session ${resolved.sessionId} was not found.`);
         }
-        const targetSessionId = trimOptional(input.target_session_id) ?? sourceSession.linkedSessionId;
+        const targetSessionId = trimOptional(input.target_session_id);
         if (!targetSessionId) {
-            throw new Error("This session has no linked partner. Link another session in Telegram first.");
+            throw new Error("target_session_id is required for send_partner_note.");
         }
         const targetSession = await this.sessionStore.getSession(targetSessionId);
         if (!targetSession) {
@@ -181,7 +140,7 @@ class LocalCollaborationBackend {
         }
         const targetBinding = await this.bindingStore.getBinding(targetSession.sessionId);
         if (!targetBinding) {
-            throw new Error(`Linked partner session ${targetSession.sessionId} is not paired with Telegram.`);
+            throw new Error(`Target session ${targetSession.sessionId} has no active Telegram route.`);
         }
         const now = new Date();
         const createdAt = now.toISOString();
@@ -210,7 +169,7 @@ class LocalCollaborationBackend {
             message: input.message,
             ...(expectedReply ? { expectedReply } : {}),
         });
-        const notePath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, relativeNotePath, this.textEncoder.encode(noteContent));
+        const notePath = await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, targetWorkspaceDir, this.config.exchange.dir, relativeNotePath, this.textEncoder.encode(noteContent));
         await this.xchangeFileMetaStore.setXchangeFileMeta({
             sessionId: targetSession.sessionId,
             filePath: notePath,
@@ -220,32 +179,81 @@ class LocalCollaborationBackend {
             mimeType: "text/markdown",
             sizeBytes: this.textEncoder.encode(noteContent).byteLength,
         });
-        const shareIndexPath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, PARTNER_INDEX_FILE_NAME, this.textEncoder.encode(`${buildShareIndexLine({
-            createdAt,
-            sourceLabel,
-            targetLabel,
+        const targetActionDesc = (0, xchangeRecordHints_1.buildIncomingPartnerActionDesc)(input.kind, requiresReply);
+        const targetTools = (0, xchangeRecordHints_1.buildIncomingPartnerTools)(input.kind, requiresReply);
+        await (0, sqliteRecordStore_1.upsertXchangeRecord)(this.config.terminal, targetWorkspaceDir, this.config.exchange.dir, {
+            record_id: shareId,
+            session_id: targetSession.sessionId,
+            category: "partner_note",
+            direction: "incoming",
+            status: "new",
             kind: input.kind,
             summary: input.summary.trim(),
-            relativeNotePath,
-        })}\n`), { append: true });
-        const inboxMessage = {
-            id: (0, ids_1.createInboxMessageId)(now),
-            sessionId: targetSession.sessionId,
-            telegramChatId: targetBinding.telegramChatId,
-            telegramUserId: targetBinding.telegramUserId,
-            sourceTelegramMessageId: now.getTime(),
-            text: buildPartnerInboxText({
-                kind: input.kind,
-                fromLabel: sourceLabel,
-                summary: input.summary.trim(),
-                notePath,
-                requiresReply,
-                copiedArtifacts,
-            }),
-            attachments: [notePath, ...copiedArtifacts],
-            receivedAt: createdAt,
-        };
-        await this.inboxStore.createInboxMessage(inboxMessage);
+            body_text: noteContent,
+            action_desc: targetActionDesc,
+            tools: targetTools,
+            note_path: notePath,
+            note_relative_path: relativeNotePath,
+            source_session_id: sourceSession.sessionId,
+            source_label: sourceLabel,
+            target_session_id: targetSession.sessionId,
+            target_label: targetLabel,
+            requires_reply: requiresReply,
+            ...(inReplyTo ? { in_reply_to: inReplyTo } : {}),
+            ...(expectedReply ? { expected_reply: expectedReply } : {}),
+            attachments: [
+                {
+                    file_path: notePath,
+                    relative_path: relativeNotePath,
+                    original_name: node_path_1.default.basename(relativeNotePath),
+                    mime_type: "text/markdown",
+                    size_bytes: this.textEncoder.encode(noteContent).byteLength,
+                },
+                ...copiedArtifacts.map((filePath) => ({
+                    file_path: filePath,
+                })),
+            ],
+            tags: [
+                "partner",
+                input.kind,
+                ...(requiresReply ? ["requires-reply"] : []),
+            ],
+            created_at: createdAt,
+            updated_at: createdAt,
+        });
+        await (0, sqliteRecordStore_1.upsertXchangeRecord)(this.config.terminal, sourceWorkspaceDir, this.config.exchange.dir, {
+            record_id: shareId,
+            session_id: sourceSession.sessionId,
+            category: "partner_note",
+            direction: "outgoing",
+            status: "read",
+            kind: input.kind,
+            summary: input.summary.trim(),
+            body_text: noteContent,
+            action_desc: (0, xchangeRecordHints_1.buildOutgoingPartnerActionDesc)(input.kind, requiresReply),
+            tools: (0, xchangeRecordHints_1.buildOutgoingPartnerTools)(input.kind, requiresReply),
+            note_path: notePath,
+            note_relative_path: relativeNotePath,
+            source_session_id: sourceSession.sessionId,
+            source_label: sourceLabel,
+            target_session_id: targetSession.sessionId,
+            target_label: targetLabel,
+            requires_reply: requiresReply,
+            ...(inReplyTo ? { in_reply_to: inReplyTo } : {}),
+            ...(expectedReply ? { expected_reply: expectedReply } : {}),
+            attachments: copiedArtifacts.map((filePath) => ({
+                file_path: filePath,
+            })),
+            tags: [
+                "partner",
+                "outgoing",
+                input.kind,
+                ...(requiresReply ? ["awaiting-reply"] : []),
+            ],
+            created_at: createdAt,
+            updated_at: createdAt,
+            read_at: createdAt,
+        });
         await this.telegramTransport.sendNotification({
             sessionId: targetSession.sessionId,
             sessionLabel: sourceLabel,
@@ -280,10 +288,13 @@ class LocalCollaborationBackend {
             ].join("\n"),
         });
         try {
-            await this.telegramTransport.nudgeSessionPartnerNote(targetSession.sessionId);
+            await this.telegramTransport.nudgeSessionPartnerNote(targetSession.sessionId, {
+                kind: input.kind,
+                requiresReply,
+            });
         }
         catch (error) {
-            this.logger.warn("tmux nudge failed after local partner delivery", {
+            this.logger.warn("terminal nudge failed after local partner delivery", {
                 sessionId: targetSession.sessionId,
                 partnerSessionId: sourceSession.sessionId,
                 shareId,
@@ -307,9 +318,9 @@ class LocalCollaborationBackend {
             share_id: shareId,
             delivery_status: "delivered",
             note_path: notePath,
-            share_index_path: shareIndexPath,
+            xchange_record_id: shareId,
             copied_artifacts: copiedArtifacts,
-            inbox_message_id: inboxMessage.id,
+            inbox_message_id: shareId,
             requires_reply: requiresReply,
         };
     }
@@ -318,7 +329,7 @@ class LocalCollaborationBackend {
         if (workspaceDir) {
             return workspaceDir;
         }
-        return process.cwd();
+        throw new Error(`Workspace cwd is not registered for console '${session.sessionId}'.`);
     }
     async copyArtifactsToPartner(sourceSession, targetSession, sourceWorkspaceDir, targetWorkspaceDir, shareId, uploadedAt, artifacts) {
         const copied = [];
@@ -351,8 +362,8 @@ class LocalCollaborationBackend {
                     source: sourceMeta.source,
                 })
                 : artifactPath;
-            const content = await (0, client_1.readWorkspaceFile)(this.config.tmux, sourceWorkspaceDir, ensuredArtifactPath);
-            const materializedArtifactPath = await (0, client_1.writeXchangeRelativeFile)(this.config.tmux, targetWorkspaceDir, this.config.exchange.dir, relativeArtifactPath, content);
+            const content = await (0, client_1.readWorkspaceFile)(this.config.terminal, sourceWorkspaceDir, ensuredArtifactPath);
+            const materializedArtifactPath = await (0, client_1.writeXchangeRelativeFile)(this.config.terminal, targetWorkspaceDir, this.config.exchange.dir, relativeArtifactPath, content);
             await this.xchangeFileMetaStore.setXchangeFileMeta({
                 sessionId: targetSession.sessionId,
                 filePath: materializedArtifactPath,

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerFileService.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SendPartnerFileService = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const mime_types_1 = require("mime-types");
-const client_1 = require("../../../shared/integrations/tmux/client");
+const client_1 = require("../../../shared/integrations/terminal/client");
 function resolveWorkspaceDir(input) {
     if (input.inputCwd?.trim()) {
         return node_path_1.default.resolve(input.inputCwd.trim());
@@ -36,33 +36,53 @@ function normalizeWorkspaceRelativePath(workspaceDir, filePath) {
 class SendPartnerFileService {
     config;
     sessionStore;
+    maintenanceStore;
     logger;
     projectIdentityResolver;
     collaborationService;
-    constructor(config, sessionStore, logger, projectIdentityResolver, collaborationService) {
+    remoteConsoleInvoker;
+    constructor(config, sessionStore, maintenanceStore, logger, projectIdentityResolver, collaborationService, remoteConsoleInvoker) {
         this.config = config;
         this.sessionStore = sessionStore;
+        this.maintenanceStore = maintenanceStore;
         this.logger = logger;
         this.projectIdentityResolver = projectIdentityResolver;
         this.collaborationService = collaborationService;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
     }
     async send(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const sessionId = await this.normalizeSessionIdForWorkspace(resolved.sessionId);
+        const remote = this.config.distributed.mode !== "client"
+            ? await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.collaboration.sendPartnerFileRemote", {
+                ...input,
+                session_id: sessionId,
+            })
+            : null;
+        if (remote) {
+            return remote;
+        }
+        const session = await this.sessionStore.getSession(sessionId);
         const workspaceDir = resolveWorkspaceDir({
             inputCwd: input.cwd,
             sessionCwd: session?.cwd,
             resolvedCwd: resolved.cwd,
         });
         const relativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, input.file_path);
-        const fileContent = await (0, client_1.readWorkspaceFile)(this.config.tmux, workspaceDir, relativeFilePath);
+        const fileContent = await (0, client_1.readWorkspaceFile)(this.config.terminal, workspaceDir, relativeFilePath);
         const originalName = node_path_1.default.basename(relativeFilePath);
         const mimeType = (0, mime_types_1.lookup)(originalName) || "application/octet-stream";
         const output = await this.collaborationService.sendPartnerNote({
-            session_id: resolved.sessionId,
+            session_id: sessionId,
             ...(input.target_session_id?.trim()
                 ? { target_session_id: input.target_session_id.trim() }
                 : {}),
+            ...(input.target_client_uuid?.trim()
+                ? { target_client_uuid: input.target_client_uuid.trim() }
+                : {}),
+            ...(input.target_local_session_id?.trim()
+                ? { target_local_session_id: input.target_local_session_id.trim() }
+                : {}),
             ...(input.project_uuid?.trim()
                 ? { project_uuid: input.project_uuid.trim() }
                 : {}),
@@ -98,5 +118,27 @@ class SendPartnerFileService {
         });
         return output;
     }
+    async normalizeSessionIdForWorkspace(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return trimmed;
+        }
+        const direct = await this.sessionStore.getSession(trimmed);
+        if (direct) {
+            return trimmed;
+        }
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            return trimmed;
+        }
+        const localClientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        const clientUuid = trimmed.slice(0, separatorIndex).trim();
+        const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+        if (!localClientUuid || clientUuid !== localClientUuid || !localSessionId) {
+            return trimmed;
+        }
+        const localSession = await this.sessionStore.getSession(localSessionId);
+        return localSession ? localSessionId : trimmed;
+    }
 }
 exports.SendPartnerFileService = SendPartnerFileService;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerFileTool.js

@@ -18,7 +18,7 @@ class SendPartnerFileTool {
     register(server) {
         server.registerTool("send_partner_file", {
             title: "Send Partner File",
-            description: "Use this when the result must include a real local workspace file for another session. Prefer this over send_partner_note when you already have an existing file path such as sample.txt, report.pdf, or screenshot.png. The tool reads the file from the current session workspace, attaches it as an artifact, and sends the partner note in one step.",
+            description: "Use this when the result must include a real local workspace file for another console. Prefer this over send_partner_note when you already have an existing file path such as sample.txt, report.pdf, or screenshot.png. For project/collab routing, use target_session_id. For direct gateway-wide routing outside a single collab project, first call list_gateway_sessions and then pass target_client_uuid plus target_local_session_id. The tool reads the file from the current console workspace, attaches it as an artifact, and sends the partner note in one step.",
             inputSchema: schema_1.sendPartnerFileInputSchema,
             outputSchema: schema_1.sendPartnerNoteOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/collaboration/model/sendPartnerNoteTool.js

@@ -18,7 +18,7 @@ class SendPartnerNoteTool {
     register(server) {
         server.registerTool("send_partner_note", {
             title: "Send Partner Note",
-            description: "Use this for agent-to-agent collaboration: ask another session to do work, send a reply, or share results. Resolve the target explicitly for project/collab work with target_session_id and, if available, project_uuid. If the result includes an existing local file, prefer send_partner_file; mentioning the filename in message text is not enough. For required replies, the task is not complete until this tool succeeds.",
+            description: "Use this for agent-to-agent collaboration: ask another console to do work, send a reply, or share results. The canonical gateway-facing console id is session_id in the format client_uuid:local_session_id. For direct routing outside a collab project, pass that canonical console id in target_session_id. Only use target_client_uuid plus target_local_session_id when you already have those exact direct fields separately. For project/collab routing, use target_session_id equal to the project session id and, if available, project_uuid. If the result includes an existing local file, prefer send_partner_file; mentioning the filename in message text is not enough. For required replies, the task is not complete until this tool succeeds.",
             inputSchema: schema_1.sendPartnerNoteInputSchema,
             outputSchema: schema_1.sendPartnerNoteOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/distributed-client/model/gatewayClientAccess.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGatewayBaseUrl = normalizeGatewayBaseUrl;
+exports.callGatewayJson = callGatewayJson;
+exports.ensureGatewayClientUuid = ensureGatewayClientUuid;
+const node_os_1 = __importDefault(require("node:os"));
+function normalizeGatewayBaseUrl(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return url;
+}
+async function callGatewayJson(input) {
+    const url = normalizeGatewayBaseUrl(input.gatewayPublicUrl);
+    url.pathname = `${url.pathname}${input.endpointPath}`.replace(/\/{2,}/gu, "/");
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(input.gatewayAuthToken
+                ? { authorization: `Bearer ${input.gatewayAuthToken}` }
+                : {}),
+        },
+        body: JSON.stringify(input.body),
+    });
+    if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`Gateway request failed with status ${response.status}: ${message || response.statusText}`);
+    }
+    return (await response.json());
+}
+async function ensureGatewayClientUuid(input) {
+    const namespace = input.namespace || process.env.NAMESPACE || undefined;
+    const nodeId = input.nodeId || process.env.NODE_ID || undefined;
+    const systemUsername = input.systemUsername ||
+        process.env.USER ||
+        process.env.LOGNAME ||
+        (() => {
+            try {
+                return node_os_1.default.userInfo().username;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+    const existing = await input.maintenanceStore.getGatewayClientUuid();
+    if (!input.gatewayPublicUrl) {
+        throw new Error("Gateway client registration requires GATEWAY_PUBLIC_URL.");
+    }
+    const response = await callGatewayJson({
+        gatewayPublicUrl: input.gatewayPublicUrl,
+        ...(input.gatewayAuthToken
+            ? { gatewayAuthToken: input.gatewayAuthToken }
+            : {}),
+        endpointPath: "/client/register",
+        body: {
+            ...(existing ? { client_uuid: existing } : {}),
+            client_label: input.projectName ||
+                [namespace, nodeId].filter(Boolean).join("/") ||
+                input.botUsername ||
+                "tellymcp client",
+            ...(input.botUsername ? { bot_username: input.botUsername } : {}),
+            ...(input.gatewayToken ? { gateway_token: input.gatewayToken } : {}),
+            ...(input.gatewayUserUuid ? { owner_user_uuid: input.gatewayUserUuid } : {}),
+            meta: {
+                ...(namespace ? { namespace } : {}),
+                ...(nodeId ? { node_id: nodeId } : {}),
+                ...(systemUsername ? { system_username: systemUsername } : {}),
+                ...(input.gatewayUserUuid
+                    ? { gateway_user_uuid: input.gatewayUserUuid }
+                    : {}),
+            },
+        },
+    });
+    await input.maintenanceStore.setGatewayClientUuid(response.client_uuid);
+    return response.client_uuid;
+}

package/dist/services/features/telegram-mcp/src/features/distributed-client/model/gatewayCollaborationBackend.js

@@ -1,35 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayCollaborationBackend = void 0;
-function normalizeGatewayBaseUrl(value) {
-    const url = new URL(value);
-    url.pathname = url.pathname.replace(/\/+$/u, "");
-    if (!url.pathname.endsWith("/gateway")) {
-        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
-    }
-    return url;
-}
+const gatewayClientAccess_1 = require("./gatewayClientAccess");
 class GatewayCollaborationBackend {
     logger;
     maintenanceStore;
     gatewayPublicUrl;
     gatewayAuthToken;
-    constructor(logger, maintenanceStore, gatewayPublicUrl, gatewayAuthToken) {
+    gatewayToken;
+    gatewayUserUuid;
+    projectName;
+    botUsername;
+    constructor(logger, maintenanceStore, gatewayPublicUrl, gatewayAuthToken, gatewayToken, gatewayUserUuid, projectName, botUsername) {
         this.logger = logger;
         this.maintenanceStore = maintenanceStore;
         this.gatewayPublicUrl = gatewayPublicUrl;
         this.gatewayAuthToken = gatewayAuthToken;
+        this.gatewayToken = gatewayToken;
+        this.gatewayUserUuid = gatewayUserUuid;
+        this.projectName = projectName;
+        this.botUsername = botUsername;
     }
     async sendPartnerNote(input, resolved) {
         if (!this.gatewayPublicUrl) {
             throw new Error("Gateway collaboration backend requires GATEWAY_PUBLIC_URL.");
         }
-        const url = normalizeGatewayBaseUrl(this.gatewayPublicUrl);
+        const url = (0, gatewayClientAccess_1.normalizeGatewayBaseUrl)(this.gatewayPublicUrl);
         url.pathname = `${url.pathname}/partner-note`.replace(/\/{2,}/gu, "/");
-        const clientUuid = await this.maintenanceStore.getGatewayClientUuid();
-        if (!clientUuid) {
-            throw new Error("Gateway collaboration requires a registered client_uuid. Join or create a project first.");
-        }
+        const clientUuid = await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: this.maintenanceStore,
+            gatewayPublicUrl: this.gatewayPublicUrl,
+            ...(this.gatewayAuthToken
+                ? { gatewayAuthToken: this.gatewayAuthToken }
+                : {}),
+            ...(this.gatewayToken ? { gatewayToken: this.gatewayToken } : {}),
+            ...(this.gatewayUserUuid ? { gatewayUserUuid: this.gatewayUserUuid } : {}),
+            ...(this.projectName ? { projectName: this.projectName } : {}),
+            ...(this.botUsername ? { botUsername: this.botUsername } : {}),
+        });
         const response = await fetch(url, {
             method: "POST",
             headers: {