@rokrokss/claude-slack-channel 0.1.0 → 0.2.0

package/CLAUDE.md

@@ -12,6 +12,7 @@
   - `event.ts` — DM 판별, 스레드 해석, stale/empty 필터링
   - `resilience.ts` — 이벤트 중복 제거 (EventDeduplicator)
   - `permalink.ts` — Slack 퍼마링크 빌더
+  - `process.ts` — 부모 프로세스 channels 플래그 감지 (hasChannelsFlag)
   - `index.ts` — barrel re-export
 - `server.test.ts` — lib/ 테스트 (bun:test)
 

package/README.md

@@ -37,15 +37,21 @@ Claude Code 세션과 Slack을 양방향으로 연결합니다. Slack DM이나
 ```
 main()
   │
-  ├── startSocketMode()
+  ├── hasChannelsFlag()
+  │     └── 부모 프로세스(Claude Code)의 command line에서
+  │         --dangerously-load-development-channels 또는 --channels 확인
+  │
+  ├── [플래그 있음] startSocketMode()
   │     ├── web.auth.test() → botUserId 확인
   │     │     └── 실패 ──► process.exit(1)
   │     └── socket.start() → Slack 이벤트 수신 시작
   │
+  ├── [플래그 없음] Socket Mode 스킵 (Tools-only mode)
+  │
   └── mcp.connect(transport) → MCP stdio 연결
 ```
 
-Socket Mode는 항상 연결됩니다. Claude Code가 `--dangerously-load-development-channels` 플래그 없이 실행되면 channel notification을 무시하므로, 서버 측에서 별도 게이팅 없이도 안전합니다.
+Socket Mode는 부모 프로세스(Claude Code)에 channels 플래그가 있을 때만 연결됩니다. 플래그 없이 실행된 세션은 도구만 제공하며 Socket Mode를 건드리지 않으므로, 기존 channels 세션의 연결이 보호됩니다.
 
 ## 인바운드 메시지 파이프라인
 
@@ -139,7 +145,8 @@ Claude (tool call)
 server.ts          MCP 서버, Slack 클라이언트, 이벤트 핸들링
 tools.ts           MCP 도구 등록 (reply, react, delete_bot_message, fetch_dm_thread)
 lib/
-  gate.ts          접근 제어 (Access, GateOptions, gate, clientSupportsChannels)
+  gate.ts          접근 제어 (Access, GateOptions, gate)
+  process.ts       부모 프로세스 channels 플래그 감지 (hasChannelsFlag)
   security.ts      아웃바운드 게이트 (assertOutboundAllowed)
   formatting.ts    Slack mrkdwn 변환, 메시지 텍스트 추출
   audit.ts         감사 로그 (AuditEntry, auditLog)

package/bun.lock

@@ -45,7 +45,7 @@
 
     "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
 
-    "axios": ["axios@1.13.6", "", { "dependencies": { "follow-redirects": "^1.15.11", "form-data": "^4.0.5", "proxy-from-env": "^1.1.0" } }, "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ=="],
+    "axios": ["axios@1.14.0", "", { "dependencies": { "follow-redirects": "^1.15.11", "form-data": "^4.0.5", "proxy-from-env": "^2.1.0" } }, "sha512-3Y8yrqLSwjuzpXuZ0oIYZ/XGgLwUIBU3uLvbcpb0pidD9ctpShJd43KSlEEkVQg6DS0G9NKyzOvBfUtDKEyHvQ=="],
 
     "body-parser": ["body-parser@2.2.2", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^1.0.5", "debug": "^4.4.3", "http-errors": "^2.0.0", "iconv-lite": "^0.7.0", "on-finished": "^2.4.1", "qs": "^6.14.1", "raw-body": "^3.0.1", "type-is": "^2.0.1" } }, "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA=="],
 
@@ -199,7 +199,7 @@
 
     "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
 
-    "proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
+    "proxy-from-env": ["proxy-from-env@2.1.0", "", {}, "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA=="],
 
     "qs": ["qs@6.15.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-mAZTtNCeetKMH+pSjrb76NAM8V9a05I9aBZOHztWy/UqcJdQYNsf59vrRKWnojAT9Y+GbIvoTBC++CPHqpDBhQ=="],
 
@@ -255,7 +255,7 @@
 
     "zod": ["zod@4.3.6", "", {}, "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg=="],
 
-    "zod-to-json-schema": ["zod-to-json-schema@3.25.1", "", { "peerDependencies": { "zod": "^3.25 || ^4" } }, "sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA=="],
+    "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="],
 
     "form-data/mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
 

package/lib/gate.ts

@@ -18,16 +18,6 @@ export function defaultAccess(): Access {
   return { allowFrom: [] }
 }
 
-/**
- * Check if the MCP client supports the channel capability.
- */
-export function clientSupportsChannels(capabilities: Record<string, unknown> | undefined): boolean {
-  if (!capabilities) return false
-  const experimental = capabilities['experimental']
-  if (!experimental || typeof experimental !== 'object') return false
-  return 'claude/channel' in experimental
-}
-
 export function gate(event: unknown, opts: GateOptions): GateResult {
   const ev = event as Record<string, unknown>
 

package/lib/index.ts

@@ -5,3 +5,4 @@ export * from './audit.ts'
 export * from './event.ts'
 export * from './resilience.ts'
 export * from './permalink.ts'
+export * from './process.ts'

package/lib/process.ts

@@ -0,0 +1,63 @@
+import { execSync } from 'child_process'
+
+/**
+ * Check if a command line string contains channels-related flags.
+ */
+export function hasChannelsFlag(commandLine?: string): boolean {
+  // Environment variable override — always wins
+  if (process.env['SLACK_FORCE_SOCKET_MODE'] === '1') return true
+
+  const cmd = commandLine ?? findAncestorClaudeCommand()
+  return (
+    cmd.includes('dangerously-load-development-channels') ||
+    /--channels\b/.test(cmd)
+  )
+}
+
+/**
+ * Walk up the process tree from ppid to find a `claude` ancestor.
+ * Returns its command line, or '' if not found.
+ * Stops after 5 levels to avoid runaway traversal.
+ * Works on macOS/Linux (ps) and Windows (wmic).
+ */
+function findAncestorClaudeCommand(): string {
+  const isWindows = process.platform === 'win32'
+  try {
+    let pid = process.ppid
+    for (let i = 0; i < 5 && pid > 1; i++) {
+      const { ppid, cmd } = isWindows
+        ? getProcessInfoWindows(pid)
+        : getProcessInfoUnix(pid)
+      if (!cmd) break
+      if (/\bclaude\b/.test(cmd)) return cmd
+      pid = ppid
+    }
+  } catch { /* process query failure → return empty */ }
+  return ''
+}
+
+function getProcessInfoUnix(pid: number): { ppid: number; cmd: string } {
+  const line = execSync(`ps -o ppid=,command= -p ${pid}`, {
+    encoding: 'utf-8',
+    timeout: 3000,
+  }).trim()
+  const match = line.match(/^\s*(\d+)\s+(.+)$/)
+  if (!match) return { ppid: 0, cmd: '' }
+  return { ppid: Number(match[1]), cmd: match[2] }
+}
+
+function getProcessInfoWindows(pid: number): { ppid: number; cmd: string } {
+  const line = execSync(
+    `wmic process where ProcessId=${pid} get ParentProcessId,CommandLine /format:csv`,
+    { encoding: 'utf-8', timeout: 3000 },
+  ).trim()
+  // CSV format: Node,CommandLine,ParentProcessId
+  // First line is header, second line is data
+  const rows = line.split(/\r?\n/).filter(Boolean)
+  if (rows.length < 2) return { ppid: 0, cmd: '' }
+  const parts = rows[1].split(',')
+  if (parts.length < 3) return { ppid: 0, cmd: '' }
+  const cmd = parts.slice(1, -1).join(',') // CommandLine may contain commas
+  const ppid = Number(parts[parts.length - 1])
+  return { ppid, cmd }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokrokss/claude-slack-channel",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Two-way Slack channel for Claude Code — Slack DM과 채널 멘션으로 Claude Code 세션과 대화",
   "type": "module",
   "bin": "./server.ts",

package/server.test.ts

@@ -14,7 +14,7 @@ import {
   isStaleEvent,
   isEmptyMessage,
   EventDeduplicator,
-  clientSupportsChannels,
+  hasChannelsFlag,
   type Access,
   type AuditEntry,
   type GateOptions,
@@ -668,55 +668,51 @@ describe('EventDeduplicator', () => {
 })
 
 // ---------------------------------------------------------------------------
-// clientSupportsChannels()
+// hasChannelsFlag()
 // ---------------------------------------------------------------------------
 
-describe('clientSupportsChannels', () => {
-  test('returns false for undefined capabilities', () => {
-    expect(clientSupportsChannels(undefined)).toBe(false)
+describe('hasChannelsFlag', () => {
+  test('returns true for --dangerously-load-development-channels', () => {
+    expect(hasChannelsFlag('claude --dangerously-load-development-channels server:slack-channel')).toBe(true)
   })
 
-  test('returns false for empty capabilities', () => {
-    expect(clientSupportsChannels({})).toBe(false)
+  test('returns true for --channels flag', () => {
+    expect(hasChannelsFlag('claude --channels plugin:telegram@anthropic')).toBe(true)
   })
 
-  test('returns false when no experimental field', () => {
-    expect(clientSupportsChannels({ tools: {} })).toBe(false)
+  test('returns false for plain claude', () => {
+    expect(hasChannelsFlag('claude')).toBe(false)
   })
 
-  test('returns false when experimental is empty', () => {
-    expect(clientSupportsChannels({ experimental: {} })).toBe(false)
+  test('returns false for other flags', () => {
+    expect(hasChannelsFlag('claude --allow-dangerously-skip-permissions')).toBe(false)
   })
 
-  test('returns false when experimental has other keys but not claude/channel', () => {
-    expect(clientSupportsChannels({
-      experimental: { 'some/other': {} },
-    })).toBe(false)
+  test('returns false for empty string', () => {
+    expect(hasChannelsFlag('')).toBe(false)
   })
 
-  test('returns true when claude/channel is present', () => {
-    expect(clientSupportsChannels({
-      experimental: { 'claude/channel': {} },
-    })).toBe(true)
+  test('returns true when flag is among multiple args', () => {
+    expect(hasChannelsFlag('claude --verbose --dangerously-load-development-channels server:slack-channel --model opus')).toBe(true)
   })
 
-  test('returns true when claude/channel is present alongside other keys', () => {
-    expect(clientSupportsChannels({
-      experimental: {
-        'claude/channel': {},
-        'claude/channel/permission': {},
-      },
-    })).toBe(true)
+  test('does not match --channels as substring of another flag', () => {
+    expect(hasChannelsFlag('claude --channelsFoo bar')).toBe(false)
   })
 
-  test('returns true even if claude/channel value is null', () => {
-    expect(clientSupportsChannels({
-      experimental: { 'claude/channel': null },
-    })).toBe(true)
+  test('matches --channels=value syntax', () => {
+    expect(hasChannelsFlag('claude --channels=plugin:foo@bar')).toBe(true)
   })
 
-  test('returns false when experimental is not an object', () => {
-    expect(clientSupportsChannels({ experimental: 'string' })).toBe(false)
+  test('SLACK_FORCE_SOCKET_MODE=1 overrides detection', () => {
+    const prev = process.env['SLACK_FORCE_SOCKET_MODE']
+    try {
+      process.env['SLACK_FORCE_SOCKET_MODE'] = '1'
+      expect(hasChannelsFlag('')).toBe(true)
+    } finally {
+      if (prev === undefined) delete process.env['SLACK_FORCE_SOCKET_MODE']
+      else process.env['SLACK_FORCE_SOCKET_MODE'] = prev
+    }
   })
 })
 

package/server.ts

@@ -17,6 +17,10 @@ import { join } from 'path'
 import {
   mkdirSync,
   appendFileSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
 } from 'fs'
 import { z } from 'zod'
 import {
@@ -29,6 +33,7 @@ import {
   isStaleEvent,
   isEmptyMessage,
   EventDeduplicator,
+  hasChannelsFlag,
   type Access,
   type GateResult,
 } from './lib/index.ts'
@@ -153,7 +158,7 @@ async function resolveUserName(userId: string): Promise<string> {
 // ---------------------------------------------------------------------------
 
 const mcp = new McpServer(
-  { name: 'slack-channel', version: '0.1.0' },
+  { name: 'slack-channel', version: '0.2.0' },
   {
     capabilities: {
       experimental: {
@@ -374,7 +379,43 @@ socket.on('app_mention', async ({ event, ack }) => {
 // Startup
 // ---------------------------------------------------------------------------
 
+const PID_FILE = join(STATE_DIR, 'socket.pid')
+
+function killPreviousInstance(): void {
+  if (!existsSync(PID_FILE)) return
+  try {
+    const oldPid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10)
+    if (isNaN(oldPid) || oldPid === process.pid) return
+    // Check if process is alive (signal 0 doesn't kill, just checks)
+    process.kill(oldPid, 0)
+    debugLog(`[slack] Killing previous Socket Mode instance (pid ${oldPid})`)
+    process.kill(oldPid, 'SIGTERM')
+  } catch {
+    // Process doesn't exist or no permission — safe to proceed
+  }
+}
+
+function writePidFile(): void {
+  writeFileSync(PID_FILE, String(process.pid), 'utf-8')
+}
+
+function cleanupPidFile(): void {
+  try {
+    if (existsSync(PID_FILE) && readFileSync(PID_FILE, 'utf-8').trim() === String(process.pid)) {
+      unlinkSync(PID_FILE)
+    }
+  } catch {}
+}
+
+process.on('exit', cleanupPidFile)
+process.on('SIGTERM', () => { cleanupPidFile(); process.exit(0) })
+process.on('SIGINT', () => { cleanupPidFile(); process.exit(0) })
+
 async function startSocketMode(): Promise<void> {
+  // Kill previous instance if still running
+  killPreviousInstance()
+  writePidFile()
+
   // Resolve bot's own user ID (for mention detection + self-filtering)
   try {
     const auth = await web.auth.test()
@@ -390,17 +431,15 @@ async function startSocketMode(): Promise<void> {
 }
 
 async function main(): Promise<void> {
-  // Start Socket Mode (Slack WebSocket) — always connect regardless of client
-  // channel capability. Claude Code determines channel support on its side via
-  // --channels flag; the server cannot detect this from the MCP handshake.
-  // If the client registered channel handlers, notifications are delivered;
-  // otherwise they are silently ignored.
-  await startSocketMode().catch((err) => {
-    console.error('[slack] Socket Mode init failed:', err)
-    process.exit(1)
-  })
+  if (hasChannelsFlag()) {
+    await startSocketMode().catch((err) => {
+      console.error('[slack] Socket Mode init failed:', err)
+      process.exit(1)
+    })
+  } else {
+    debugLog('[slack] Socket Mode skipped — parent process has no channels flag. Tools-only mode.')
+  }
 
-  // Connect MCP stdio (server ↔ Claude Code)
   const transport = new StdioServerTransport()
   await mcp.connect(transport)
   debugLog('[slack] MCP server running on stdio')