@ctliz/agent-intercom-claude 0.13.0-connect.9 → 0.14.0

package/dist/claude-server.mjs

@@ -1847,6 +1847,12 @@ function loadConfig() {
 // claude/inbox.ts
 import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname3, join as join5 } from "node:path";
+function sanitizeInboxSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "session";
+}
+function defaultInboxPath(sessionId, intercomDir = getIntercomDirPath()) {
+  return join5(intercomDir, `inbox-${sanitizeInboxSegment(sessionId)}.jsonl`);
+}
 function toInboxEntry(from, message, now = Date.now()) {
   return {
     ts: now,
@@ -2436,6 +2442,7 @@ var ClaudeIntercomRuntime = class {
   reconnectTimer = null;
   reconnectAttempt = 0;
   reconnectEnabled = true;
+  registrationConflict = null;
   identity;
   unread = [];
   unresolvedAsks = /* @__PURE__ */ new Map();
@@ -2460,7 +2467,34 @@ var ClaudeIntercomRuntime = class {
   getIdentity() {
     return this.identity;
   }
+  async syncSession(identity) {
+    const changed = identity.sessionId !== this.identity.sessionId || identity.cwd !== this.identity.cwd;
+    if (changed) {
+      await this.disconnect();
+      this.unread = [];
+      this.unresolvedAsks.clear();
+      this.registrationConflict = null;
+    }
+    const renamed = identity.name !== this.identity.name;
+    const modelChanged = identity.model !== this.identity.model;
+    this.identity = identity;
+    if (changed) await this.connect();
+    else if (renamed || modelChanged) this.client?.updatePresence({ name: identity.name, model: identity.model });
+  }
+  pauseOnRegistrationConflict(error2) {
+    let cause = error2;
+    for (let depth = 0; cause instanceof Error && depth < 8; depth++, cause = cause.cause) {
+      if (cause.code === "SESSION_ID_IN_USE") {
+        this.registrationConflict = cause;
+        this.reconnectEnabled = false;
+        this.clearReconnectTimer();
+        return true;
+      }
+    }
+    return false;
+  }
   async connect() {
+    if (this.registrationConflict) throw this.registrationConflict;
     this.reconnectEnabled = true;
     this.clearReconnectTimer();
     if (this.client?.isConnected()) return this.client;
@@ -2468,6 +2502,9 @@ var ClaudeIntercomRuntime = class {
     this.connectPromise = this.connectOnce();
     try {
       return await this.connectPromise;
+    } catch (error2) {
+      this.pauseOnRegistrationConflict(error2);
+      throw error2;
     } finally {
       this.connectPromise = null;
     }
@@ -2479,32 +2516,36 @@ var ClaudeIntercomRuntime = class {
       this.handleIncomingMessage(from, message);
       client.acknowledgeMessage(deliveryId);
     });
+    client.on("error", (error2) => {
+      this.pauseOnRegistrationConflict(error2);
+      process.stderr.write(`claude-intercom: ${error2.message}
+`);
+    });
     client.on("disconnected", (error2) => {
-      for (const waiter of this.replyWaiters.values()) {
-        clearTimeout(waiter.timeout);
-        waiter.cleanup?.();
-        waiter.reject(new Error(`Disconnected while waiting for reply: ${error2.message}`, { cause: error2 }));
-      }
-      this.replyWaiters.clear();
+      this.rejectReplyWaiters(new Error(`Disconnected while waiting for reply: ${error2.message}`, { cause: error2 }));
       if (this.client === client) this.client = null;
       this.scheduleReconnect();
     });
+    const registeredIdentity = this.identity;
     await client.connect({
-      name: this.identity.name,
-      cwd: this.identity.cwd,
-      model: this.identity.model,
+      name: registeredIdentity.name,
+      cwd: registeredIdentity.cwd,
+      model: registeredIdentity.model,
       pid: process.pid,
-      startedAt: this.identity.startedAt,
+      startedAt: registeredIdentity.startedAt,
       lastActivity: Date.now(),
       status: "idle"
-    }, this.identity.sessionId);
+    }, registeredIdentity.sessionId);
     this.client = client;
+    if (registeredIdentity.name !== this.identity.name || registeredIdentity.model !== this.identity.model) {
+      client.updatePresence({ name: this.identity.name, model: this.identity.model });
+    }
     this.reconnectAttempt = 0;
     return client;
   }
   scheduleReconnect() {
     if (!this.reconnectEnabled || this.reconnectTimer) return;
-    const delay = this.reconnectDelays[Math.min(this.reconnectAttempt, this.reconnectDelays.length - 1)];
+    const delay2 = this.reconnectDelays[Math.min(this.reconnectAttempt, this.reconnectDelays.length - 1)];
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       void this.connect().then((client) => {
@@ -2516,7 +2557,7 @@ var ClaudeIntercomRuntime = class {
         this.reconnectAttempt += 1;
         this.scheduleReconnect();
       });
-    }, delay);
+    }, delay2);
     this.reconnectTimer.unref?.();
   }
   clearReconnectTimer() {
@@ -2524,8 +2565,17 @@ var ClaudeIntercomRuntime = class {
     clearTimeout(this.reconnectTimer);
     this.reconnectTimer = null;
   }
+  rejectReplyWaiters(error2) {
+    for (const waiter of this.replyWaiters.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.cleanup?.();
+      waiter.reject(error2);
+    }
+    this.replyWaiters.clear();
+  }
   async disconnect() {
     this.reconnectEnabled = false;
+    this.rejectReplyWaiters(new Error("Claude session disconnected while waiting for reply"));
     this.clearReconnectTimer();
     if (this.connectPromise) {
       try {
@@ -2600,12 +2650,9 @@ var ClaudeIntercomRuntime = class {
     if (message.expectsReply) {
       this.unresolvedAsks.set(message.id, entry);
     }
-    const inboxPath = process.env.CLAUDE_INTERCOM_INBOX;
-    if (inboxPath) {
-      try {
-        appendInboxMessage(inboxPath, from, message);
-      } catch {
-      }
+    try {
+      appendInboxMessage(process.env.CLAUDE_INTERCOM_INBOX || defaultInboxPath(this.identity.sessionId), from, message);
+    } catch {
     }
   }
   waitForReply(from, replyTo, timeoutMs = getAskTimeoutMs(), signal) {
@@ -2657,6 +2704,17 @@ cwd: ${this.identity.cwd}`,
     return textResult(formatIntercomTeam(team), team);
   }
   async status() {
+    if (this.registrationConflict) {
+      return textResult(`Connected: No
+Session ID: ${this.identity.sessionId}
+Registration conflict: ${this.registrationConflict.message}
+Automatic reconnect paused; the incumbent session was not replaced.`, {
+        connected: false,
+        session_id: this.identity.sessionId,
+        registration_conflict: { code: "SESSION_ID_IN_USE", message: this.registrationConflict.message },
+        reconnect_paused: true
+      }, true);
+    }
     const client = await this.connect();
     const sessions = await client.listSessions();
     return textResult(
@@ -2813,21 +2871,21 @@ var attachmentsSchema = {
     additionalProperties: false
   }
 };
-function buildToolDefinitions(runtime2) {
+function buildToolDefinitions(runtime) {
   const tools = [
     {
       name: "intercom_whoami",
       description: "Return this Claude session's intercom identity for reliable targeting.",
       inputSchema: { type: "object", properties: {}, additionalProperties: false },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-      handler: async () => runtime2.whoami()
+      handler: async () => runtime.whoami()
     },
     {
       name: "intercom_team",
       description: "Show your current manager and the live coworkers owned by that manager. No arguments are required.",
       inputSchema: { type: "object", properties: {}, additionalProperties: false },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-      handler: async () => runtime2.team()
+      handler: async () => runtime.team()
     },
     {
       name: "intercom_join",
@@ -2841,7 +2899,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-      handler: async (args) => runtime2.join(
+      handler: async (args) => runtime.join(
         typeof args.name === "string" ? args.name : void 0,
         args.create === true
       )
@@ -2851,7 +2909,7 @@ function buildToolDefinitions(runtime2) {
       description: "Show intercom connection status, active sessions, unread messages, and pending asks.",
       inputSchema: { type: "object", properties: {}, additionalProperties: false },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-      handler: async () => runtime2.status()
+      handler: async () => runtime.status()
     },
     {
       name: "intercom_list",
@@ -2865,7 +2923,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-      handler: async (args) => runtime2.list(
+      handler: async (args) => runtime.list(
         args.scope === "directory" || args.scope === "repo" ? args.scope : "machine",
         asBoolean(args.include_self, false)
       )
@@ -2880,7 +2938,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
-      handler: async (args) => runtime2.setSummary(asString(args.summary, "summary"))
+      handler: async (args) => runtime.setSummary(asString(args.summary, "summary"))
     },
     {
       name: "intercom_send",
@@ -2896,7 +2954,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-      handler: async (args) => runtime2.send(asString(args.to, "to"), asString(args.message, "message"), asAttachmentArray(args.attachments))
+      handler: async (args) => runtime.send(asString(args.to, "to"), asString(args.message, "message"), asAttachmentArray(args.attachments))
     },
     {
       name: "intercom_ask",
@@ -2913,7 +2971,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-      handler: async (args, signal) => runtime2.ask(
+      handler: async (args, signal) => runtime.ask(
         asString(args.to, "to"),
         asString(args.message, "message"),
         asAttachmentArray(args.attachments),
@@ -2930,7 +2988,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
-      handler: async (args) => runtime2.pending(asBoolean(args.mark_read, false))
+      handler: async (args) => runtime.pending(asBoolean(args.mark_read, false))
     },
     {
       name: "intercom_reply",
@@ -2946,7 +3004,7 @@ function buildToolDefinitions(runtime2) {
         additionalProperties: false
       },
       annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
-      handler: async (args) => runtime2.reply(asString(args.message, "message"), typeof args.to === "string" ? args.to : void 0, args.which === "oldest" || args.which === "latest" ? args.which : void 0)
+      handler: async (args) => runtime.reply(asString(args.message, "message"), typeof args.to === "string" ? args.to : void 0, args.which === "oldest" || args.which === "latest" ? args.which : void 0)
     }
   ];
   return tools;
@@ -2957,7 +3015,7 @@ function ok(id, result) {
 function error(id, code, message) {
   return { jsonrpc: "2.0", id: id ?? null, error: { code, message } };
 }
-async function handleMcpRequest(request, runtime2) {
+async function handleMcpRequest(request, runtime) {
   if (!request.method) {
     return error(request.id, -32600, "Invalid request");
   }
@@ -2971,13 +3029,13 @@ async function handleMcpRequest(request, runtime2) {
   if (request.id === void 0 && request.method.startsWith("notifications/")) {
     return void 0;
   }
-  const tools = buildToolDefinitions(runtime2);
+  const tools = buildToolDefinitions(runtime);
   switch (request.method) {
     case "initialize":
       return ok(request.id, {
         protocolVersion: "2025-06-18",
         capabilities: { tools: {} },
-        serverInfo: { name: "claude-intercom", version: "0.1.0" }
+        serverInfo: { name: "claude-intercom", version: "0.14.0" }
       });
     case "ping":
       return ok(request.id, {});
@@ -3011,19 +3069,169 @@ async function handleMcpRequest(request, runtime2) {
   }
 }
 
+// claude/session-lifecycle.ts
+import { execFileSync } from "node:child_process";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync7, readSync, renameSync as renameSync3, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, dirname as dirname4, join as join8 } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { setTimeout as delay } from "node:timers/promises";
+function findClaudeHost(pid = process.ppid) {
+  for (let depth = 0; pid > 1 && depth < 16; depth++) {
+    let parts;
+    try {
+      parts = execFileSync(
+        "ps",
+        ["-p", String(pid), "-o", "ppid=", "-o", "lstart=", "-o", "comm="],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim().split(/\s+/);
+    } catch {
+      return void 0;
+    }
+    const command = basename2(parts.slice(6).join(" "));
+    if (/^claude(?:\.exe)?$/i.test(command)) {
+      return { pid, startedAt: parts.slice(1, 6).join(" ") };
+    }
+    if (!/^(sh|bash|zsh|dash|fish)$/.test(command)) return void 0;
+    pid = Number(parts[0]);
+  }
+  return void 0;
+}
+function claudeSessionMetadataPath(host) {
+  return join8(getIntercomDirPath(), `claude-host-${host.pid}.json`);
+}
+function readClaudeSessionMetadata(path, host) {
+  try {
+    const data = JSON.parse(readFileSync7(path, "utf8"));
+    if (data.hostStartedAt !== host.startedAt || typeof data.sessionId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(data.sessionId) || typeof data.cwd !== "string" || typeof data.transcriptPath !== "string" || typeof data.startedAt !== "number" || typeof data.ended !== "boolean" || data.name !== void 0 && typeof data.name !== "string" || data.model !== void 0 && typeof data.model !== "string") return void 0;
+    return data;
+  } catch {
+    return void 0;
+  }
+}
+function claudeIdentityForSession(metadata, env = process.env, pid = process.pid) {
+  const identity = buildClaudeRuntimeIdentity(env, metadata?.cwd ?? env.PWD ?? process.cwd(), pid);
+  if (!metadata) return identity;
+  if (!env.CLAUDE_INTERCOM_SESSION_ID?.trim() && !env.CLAUDE_PEER_ID?.trim() && !env.AGENT_INTERCOM_SESSION_ID?.trim()) {
+    identity.sessionId = `claude-${metadata.sessionId}`;
+  }
+  identity.name = metadata.name?.trim() || identity.name;
+  if (!env.CLAUDE_INTERCOM_MODEL?.trim()) identity.model = metadata.model?.trim() || identity.model;
+  identity.startedAt = metadata.startedAt;
+  return identity;
+}
+var ClaudeSessionReader = class {
+  constructor(path, host) {
+    this.path = path;
+    this.host = host;
+  }
+  path;
+  host;
+  transcriptPath = "";
+  sessionId = "";
+  offset = 0;
+  partial = "";
+  decoder = new StringDecoder("utf8");
+  name;
+  startedAt = 0;
+  read() {
+    const metadata = readClaudeSessionMetadata(this.path, this.host);
+    if (!metadata || metadata.ended) return metadata;
+    if (metadata.sessionId !== this.sessionId || metadata.transcriptPath !== this.transcriptPath || metadata.startedAt !== this.startedAt) {
+      this.sessionId = metadata.sessionId;
+      this.transcriptPath = metadata.transcriptPath;
+      this.startedAt = metadata.startedAt;
+      this.name = void 0;
+      this.partial = "";
+      this.decoder = new StringDecoder("utf8");
+      try {
+        this.offset = Math.max(0, statSync(this.transcriptPath).size - 64 * 1024);
+      } catch {
+        this.offset = 0;
+      }
+    }
+    let fd;
+    try {
+      fd = openSync2(this.transcriptPath, "r");
+      const size = statSync(this.transcriptPath).size;
+      if (size < this.offset) {
+        this.offset = 0;
+        this.partial = "";
+        this.decoder = new StringDecoder("utf8");
+      }
+      const buffer = Buffer.alloc(Math.min(size - this.offset, 64 * 1024));
+      const count = readSync(fd, buffer, 0, buffer.length, this.offset);
+      this.offset += count;
+      const lines = (this.partial + this.decoder.write(buffer.subarray(0, count))).split("\n");
+      this.partial = lines.pop() ?? "";
+      if (this.partial.length > 64 * 1024) this.partial = "";
+      for (const line of lines) {
+        if (!line.includes('"custom-title"')) continue;
+        try {
+          const record = JSON.parse(line);
+          if (record.type === "custom-title" && record.sessionId === metadata.sessionId && typeof record.customTitle === "string" && record.customTitle.trim()) this.name = record.customTitle;
+        } catch {
+        }
+      }
+    } catch {
+    } finally {
+      if (fd !== void 0) closeSync2(fd);
+    }
+    return { ...metadata, name: this.name ?? metadata.name };
+  }
+};
+async function waitForClaudeSession(reader) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const metadata = reader.read();
+    if (metadata) return metadata;
+    await delay(50);
+  }
+  return reader.read();
+}
+
 // claude/server.ts
-var runtime = new ClaudeIntercomRuntime();
-if (process.env.CLAUDE_INTERCOM_INBOX) {
-  void runtime.connect().catch((error2) => {
-    process.stderr.write(`claude-intercom: eager connect failed: ${error2 instanceof Error ? error2.message : String(error2)}
+var shuttingDown = false;
+var stopPolling = () => {
+};
+var pendingSync = Promise.resolve();
+var report = (error2) => {
+  process.stderr.write(`claude-intercom: ${error2 instanceof Error ? error2.message : String(error2)}
 `);
-  });
-}
+};
+var runtimeReady = (async () => {
+  const host = findClaudeHost();
+  const reader = host ? new ClaudeSessionReader(claudeSessionMetadataPath(host), host) : void 0;
+  const metadata = reader ? await waitForClaudeSession(reader) : void 0;
+  const runtime = new ClaudeIntercomRuntime(claudeIdentityForSession(metadata, process.env, host?.pid));
+  if (!shuttingDown && !metadata?.ended) void runtime.connect().catch(report);
+  if (reader && !shuttingDown) {
+    let previous = JSON.stringify(metadata);
+    let syncing = false;
+    const timer = setInterval(() => {
+      if (syncing || shuttingDown) return;
+      const next = reader.read();
+      const signature = JSON.stringify(next);
+      if (!next || signature === previous) return;
+      previous = signature;
+      syncing = true;
+      pendingSync = (async () => {
+        if (next.ended) await runtime.disconnect();
+        else {
+          await runtime.syncSession(claudeIdentityForSession(next, process.env, host.pid));
+          await runtime.connect();
+        }
+      })().catch(report).finally(() => {
+        syncing = false;
+      });
+    }, 250);
+    timer.unref();
+    stopPolling = () => clearInterval(timer);
+  }
+  return runtime;
+})();
 var rl = readline.createInterface({
   input: stdin,
   crlfDelay: Infinity
 });
-var shuttingDown = false;
 var pendingRequests = 0;
 function writeResponse(response) {
   if (!response) return;
@@ -3032,7 +3240,11 @@ function writeResponse(response) {
 }
 function maybeShutdown() {
   if (!shuttingDown || pendingRequests > 0) return;
-  void runtime.disconnect().finally(() => process.exit(0));
+  stopPolling();
+  void runtimeReady.then(async (runtime) => {
+    await pendingSync;
+    await runtime.disconnect();
+  }).finally(() => process.exit(0));
 }
 rl.on("line", (line) => {
   const trimmed = line.trim();
@@ -3041,7 +3253,7 @@ rl.on("line", (line) => {
   void (async () => {
     try {
       const request = JSON.parse(trimmed);
-      writeResponse(await handleMcpRequest(request, runtime));
+      writeResponse(await handleMcpRequest(request, await runtimeReady));
     } catch (error2) {
       writeResponse({
         jsonrpc: "2.0",