deplyze-code 0.1.0 → 0.1.3

package/src/tools/AgentTool/builtInAgents.ts

@@ -32,14 +32,12 @@ export function getBuiltInAgents(): AgentDefinition[] {
   // Use lazy require inside the function body to avoid circular dependency
   // issues at module init time. The coordinatorMode module depends on tools
   // which depend on AgentTool which imports this file.
-  if (feature('COORDINATOR_MODE')) {
-    if (isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)) {
-      /* eslint-disable @typescript-eslint/no-require-imports */
-      const { getCoordinatorAgents } =
-        require('../../coordinator/workerAgent.js') as typeof import('../../coordinator/workerAgent.js')
-      /* eslint-enable @typescript-eslint/no-require-imports */
-      return getCoordinatorAgents()
-    }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)) {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const { getCoordinatorAgents } =
+      require('../../coordinator/workerAgent.js') as typeof import('../../coordinator/workerAgent.js')
+    /* eslint-enable @typescript-eslint/no-require-imports */
+    return getCoordinatorAgents()
   }
 
   const agents: AgentDefinition[] = [

package/src/tools/ListPeersTool/ListPeersTool.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod/v4'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { listLocalPeers } from '../../utils/concurrentSessions.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+
+const inputSchema = lazySchema(() => z.strictObject({}))
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    peers: z.array(
+      z.object({
+        sessionId: z.string(),
+        pid: z.number(),
+        cwd: z.string(),
+        startedAt: z.number().optional(),
+        kind: z.enum(['interactive', 'bg', 'daemon', 'daemon-worker']),
+        entrypoint: z.string().optional(),
+        name: z.string().optional(),
+        status: z.enum(['busy', 'idle', 'waiting']).optional(),
+        transport: z.enum(['uds', 'deferred']),
+        address: z.string().optional(),
+        canMessage: z.boolean(),
+        reason: z.string().optional(),
+      }),
+    ),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+
+export type Output = z.infer<OutputSchema>
+
+export const ListPeersTool = buildTool({
+  name: 'ListPeers',
+  searchHint: 'list local peer sessions for inbox coordination',
+  maxResultSizeChars: 100_000,
+  async description() {
+    return 'List discoverable local Deplyze Code peer sessions and whether they can receive local messages.'
+  },
+  async prompt() {
+    return 'Use this tool to inspect discoverable local peer sessions before sending a cross-session message.'
+  },
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  userFacingName() {
+    return 'ListPeers'
+  },
+  shouldDefer: true,
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  renderToolUseMessage() {
+    return null
+  },
+  async call() {
+    return {
+      data: {
+        peers: await listLocalPeers(),
+      },
+    }
+  },
+  mapToolResultToToolResultBlockParam(content, toolUseID) {
+    const { peers } = content as Output
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content:
+        peers.length === 0 ? 'No local peers found' : jsonStringify(peers),
+    }
+  },
+} satisfies ToolDef<InputSchema, Output>)

package/src/tools.ts

@@ -117,9 +117,8 @@ const TerminalCaptureTool = feature('TERMINAL_PANEL')
 const WebBrowserTool = feature('WEB_BROWSER_TOOL')
   ? require('./tools/WebBrowserTool/WebBrowserTool.js').WebBrowserTool
   : null
-const coordinatorModeModule = feature('COORDINATOR_MODE')
-  ? (require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js'))
-  : null
+const getCoordinatorModeModule = () =>
+  require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js')
 const SnipTool = feature('HISTORY_SNIP')
   ? require('./tools/SnipTool/SnipTool.js').SnipTool
   : null
@@ -276,10 +275,7 @@ export const getTools = (permissionContext: ToolPermissionContext): Tools => {
     // below which also hides REPL_ONLY_TOOLS when REPL is enabled.
     if (isReplModeEnabled() && REPLTool) {
       const replSimple: Tool[] = [REPLTool]
-      if (
-        feature('COORDINATOR_MODE') &&
-        coordinatorModeModule?.isCoordinatorMode()
-      ) {
+      if (getCoordinatorModeModule().isCoordinatorMode()) {
         replSimple.push(TaskStopTool, getSendMessageTool())
       }
       return filterToolsByDenyRules(replSimple, permissionContext)
@@ -288,10 +284,7 @@ export const getTools = (permissionContext: ToolPermissionContext): Tools => {
     // When coordinator mode is also active, include AgentTool and TaskStopTool
     // so the coordinator gets Task+TaskStop (via useMergedTools filtering) and
     // workers get Bash/Read/Edit (via filterToolsForAgent filtering).
-    if (
-      feature('COORDINATOR_MODE') &&
-      coordinatorModeModule?.isCoordinatorMode()
-    ) {
+    if (getCoordinatorModeModule().isCoordinatorMode()) {
       simpleTools.push(AgentTool, TaskStopTool, getSendMessageTool())
     }
     return filterToolsByDenyRules(simpleTools, permissionContext)

package/src/utils/concurrentSessions.ts

@@ -11,17 +11,146 @@ import { logForDebugging } from './debug.js'
 import { getClaudeConfigHomeDir } from './envUtils.js'
 import { errorMessage, isFsInaccessible } from './errors.js'
 import { isProcessRunning } from './genericProcessUtils.js'
-import { getPlatform } from './platform.js'
+import { getPlatform, SUPPORTED_PLATFORMS } from './platform.js'
 import { jsonParse, jsonStringify } from './slowOperations.js'
 import { getAgentId } from './teammate.js'
 
 export type SessionKind = 'interactive' | 'bg' | 'daemon' | 'daemon-worker'
 export type SessionStatus = 'busy' | 'idle' | 'waiting'
+export type RegisteredSessionRecord = {
+  pid: number
+  sessionId?: string
+  cwd?: string
+  startedAt?: number
+  kind: SessionKind
+  entrypoint?: string
+  messagingSocketPath?: string
+  name?: string
+  logPath?: string
+  agent?: string
+  bridgeSessionId?: string | null
+  status?: SessionStatus
+  waitingFor?: string
+  updatedAt?: number
+}
+
+export type LocalPeerTransport = 'uds' | 'deferred'
+
+export type LocalPeer = {
+  sessionId: string
+  pid: number
+  cwd: string
+  startedAt?: number
+  kind: SessionKind
+  entrypoint?: string
+  name?: string
+  status?: SessionStatus
+  transport: LocalPeerTransport
+  address?: string
+  canMessage: boolean
+  reason?: string
+}
 
 function getSessionsDir(): string {
   return join(getClaudeConfigHomeDir(), 'sessions')
 }
 
+function isSessionRegistryFile(file: string): boolean {
+  return /^\d+\.json$/.test(file)
+}
+
+function sanitizeSessionRecord(
+  pid: number,
+  raw: unknown,
+): RegisteredSessionRecord | null {
+  if (!raw || typeof raw !== 'object') return null
+  const record = raw as Record<string, unknown>
+  return {
+    pid,
+    sessionId:
+      typeof record.sessionId === 'string' ? record.sessionId : undefined,
+    cwd: typeof record.cwd === 'string' ? record.cwd : undefined,
+    startedAt:
+      typeof record.startedAt === 'number' ? record.startedAt : undefined,
+    kind:
+      record.kind === 'bg' ||
+      record.kind === 'daemon' ||
+      record.kind === 'daemon-worker'
+        ? record.kind
+        : 'interactive',
+    entrypoint:
+      typeof record.entrypoint === 'string' ? record.entrypoint : undefined,
+    messagingSocketPath:
+      typeof record.messagingSocketPath === 'string'
+        ? record.messagingSocketPath
+        : undefined,
+    name: typeof record.name === 'string' ? record.name : undefined,
+    logPath: typeof record.logPath === 'string' ? record.logPath : undefined,
+    agent: typeof record.agent === 'string' ? record.agent : undefined,
+    bridgeSessionId:
+      typeof record.bridgeSessionId === 'string' ||
+      record.bridgeSessionId === null
+        ? record.bridgeSessionId
+        : undefined,
+    status:
+      record.status === 'busy' ||
+      record.status === 'idle' ||
+      record.status === 'waiting'
+        ? record.status
+        : undefined,
+    waitingFor:
+      typeof record.waitingFor === 'string' ? record.waitingFor : undefined,
+    updatedAt:
+      typeof record.updatedAt === 'number' ? record.updatedAt : undefined,
+  }
+}
+
+async function readLiveSessionRecords(options?: {
+  includeCurrentProcess?: boolean
+}): Promise<RegisteredSessionRecord[]> {
+  const dir = getSessionsDir()
+  let files: string[]
+  try {
+    files = await readdir(dir)
+  } catch (e) {
+    if (!isFsInaccessible(e)) {
+      logForDebugging(`[concurrentSessions] readdir failed: ${errorMessage(e)}`)
+    }
+    return []
+  }
+
+  const includeCurrentProcess = options?.includeCurrentProcess ?? true
+  const records: RegisteredSessionRecord[] = []
+  for (const file of files) {
+    if (!isSessionRegistryFile(file)) continue
+
+    const pid = parseInt(file.slice(0, -5), 10)
+    const isCurrentProcess = pid === process.pid
+    const isLive = isCurrentProcess || isProcessRunning(pid)
+    if (!isLive) {
+      if (getPlatform() !== 'wsl') {
+        void unlink(join(dir, file)).catch(() => {})
+      }
+      continue
+    }
+    if (!includeCurrentProcess && isCurrentProcess) continue
+
+    try {
+      const parsed = jsonParse(await readFile(join(dir, file), 'utf8'))
+      const record = sanitizeSessionRecord(pid, parsed)
+      if (record) {
+        records.push(record)
+      }
+    } catch (e) {
+      logForDebugging(
+        `[concurrentSessions] failed to read ${file}: ${errorMessage(e)}`,
+      )
+    }
+  }
+
+  return records.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0))
+}
+
 /**
  * Kind override from env. Set by the spawner (`claude --bg`, daemon
  * supervisor) so the child can register without the parent having to
@@ -166,39 +295,60 @@ export async function updateSessionActivity(patch: {
  * Returns 0 on any error (conservative).
  */
 export async function countConcurrentSessions(): Promise<number> {
-  const dir = getSessionsDir()
-  let files: string[]
-  try {
-    files = await readdir(dir)
-  } catch (e) {
-    if (!isFsInaccessible(e)) {
-      logForDebugging(`[concurrentSessions] readdir failed: ${errorMessage(e)}`)
-    }
-    return 0
-  }
+  return (await readLiveSessionRecords()).length
+}
 
-  let count = 0
-  for (const file of files) {
-    // Strict filename guard: only `<pid>.json` is a candidate. parseInt's
-    // lenient prefix-parsing means `2026-03-14_notes.md` would otherwise
-    // parse as PID 2026 and get swept as stale — silent user data loss.
-    // See anthropics/claude-code#34210.
-    if (!/^\d+\.json$/.test(file)) continue
-    const pid = parseInt(file.slice(0, -5), 10)
-    if (pid === process.pid) {
-      count++
-      continue
+export async function listAllLiveSessions(options?: {
+  includeCurrentProcess?: boolean
+}): Promise<RegisteredSessionRecord[]> {
+  return readLiveSessionRecords(options)
+}
+
+export async function listLocalPeers(): Promise<LocalPeer[]> {
+  const platform = getPlatform()
+  const supportsUds = SUPPORTED_PLATFORMS.includes(platform)
+  const sessions = await listAllLiveSessions({ includeCurrentProcess: false })
+  const peersBySessionId = new Map<string, LocalPeer>()
+
+  for (const session of sessions) {
+    if (!session.sessionId || !session.cwd) continue
+
+    const hasSocket =
+      typeof session.messagingSocketPath === 'string' &&
+      session.messagingSocketPath.trim().length > 0
+    const canMessage = supportsUds && hasSocket
+    const peer: LocalPeer = {
+      sessionId: session.sessionId,
+      pid: session.pid,
+      cwd: session.cwd,
+      startedAt: session.startedAt,
+      kind: session.kind,
+      entrypoint: session.entrypoint,
+      name: session.name,
+      status: session.status,
+      transport: canMessage ? 'uds' : 'deferred',
+      address: canMessage ? `uds:${session.messagingSocketPath}` : undefined,
+      canMessage,
+      reason: canMessage
+        ? undefined
+        : platform === 'windows'
+          ? 'Local UDS messaging is deferred on native Windows in this phase.'
+          : hasSocket
+            ? 'This session is not advertising a usable local messaging socket.'
+            : 'This session is not advertising a local messaging socket.',
     }
-    if (isProcessRunning(pid)) {
-      count++
-    } else if (getPlatform() !== 'wsl') {
-      // Stale file from a crashed session — sweep it. Skip on WSL: if
-      // ~/.claude/sessions/ is shared with Windows-native Claude (symlink
-      // or CLAUDE_CONFIG_DIR), a Windows PID won't be probeable from WSL
-      // and we'd falsely delete a live session's file. This is just
-      // telemetry so conservative undercount is acceptable.
-      void unlink(join(dir, file)).catch(() => {})
+
+    const existing = peersBySessionId.get(peer.sessionId)
+    if (
+      !existing ||
+      (!existing.canMessage && peer.canMessage) ||
+      (existing.startedAt ?? 0) < (peer.startedAt ?? 0)
+    ) {
+      peersBySessionId.set(peer.sessionId, peer)
     }
   }
-  return count
+
+  return [...peersBySessionId.values()].sort(
+    (a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0),
+  )
 }

package/src/utils/sessionRestore.ts

@@ -254,7 +254,7 @@ export async function refreshAgentDefinitionsForModeSwitch(
   cliAgents: AgentDefinition[],
   currentAgentDefinitions: AgentDefinitionsResult,
 ): Promise<AgentDefinitionsResult> {
-  if (!feature('COORDINATOR_MODE') || !modeWasSwitched) {
+  if (!modeWasSwitched) {
     return currentAgentDefinitions
   }
 
@@ -425,11 +425,9 @@ export async function processResumedConversation(
 ): Promise<ProcessedResume> {
   // Match coordinator/normal mode to the resumed session
   let modeWarning: string | undefined
-  if (feature('COORDINATOR_MODE')) {
-    modeWarning = context.modeApi?.matchSessionMode(result.mode)
-    if (modeWarning) {
-      result.messages.push(createSystemMessage(modeWarning, 'warning'))
-    }
+  modeWarning = context.modeApi?.matchSessionMode(result.mode)
+  if (modeWarning) {
+    result.messages.push(createSystemMessage(modeWarning, 'warning'))
   }
 
   // Reuse the resumed session's ID unless --fork-session is specified
@@ -511,9 +509,7 @@ export async function processResumedConversation(
     )
 
   // Persist the current mode so future resumes know what mode this session was in
-  if (feature('COORDINATOR_MODE')) {
-    saveMode(context.modeApi?.isCoordinatorMode() ? 'coordinator' : 'normal')
-  }
+  saveMode(context.modeApi?.isCoordinatorMode() ? 'coordinator' : 'normal')
 
   // Compute initial state before render (per CLAUDE.md guidelines)
   const restoredAttribution = opts.includeAttribution

package/src/utils/systemPrompt.ts

@@ -60,7 +60,6 @@ export function buildEffectiveSystemPrompt({
   // Use inline env check instead of coordinatorModule to avoid circular
   // dependency issues during test module loading.
   if (
-    feature('COORDINATOR_MODE') &&
     isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE) &&
     !mainThreadAgentDefinition
   ) {

package/src/utils/toolPool.ts

@@ -1,4 +1,3 @@
-import { feature } from 'bun:bundle'
 import partition from 'lodash-es/partition.js'
 import uniqBy from 'lodash-es/uniqBy.js'
 import { COORDINATOR_MODE_ALLOWED_TOOLS } from '../constants/tools.js'
@@ -19,9 +18,8 @@ export function isPrActivitySubscriptionTool(name: string): boolean {
 
 // Dead code elimination: conditional imports for feature-gated modules
 /* eslint-disable @typescript-eslint/no-require-imports */
-const coordinatorModeModule = feature('COORDINATOR_MODE')
-  ? (require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js'))
-  : null
+const getCoordinatorModeModule = () =>
+  require('../coordinator/coordinatorMode.js') as typeof import('../coordinator/coordinatorMode.js')
 /* eslint-enable @typescript-eslint/no-require-imports */
 
 /**
@@ -69,10 +67,8 @@ export function mergeAndFilterTools(
   const byName = (a: Tool, b: Tool) => a.name.localeCompare(b.name)
   const tools = [...builtIn.sort(byName), ...mcp.sort(byName)]
 
-  if (feature('COORDINATOR_MODE') && coordinatorModeModule) {
-    if (coordinatorModeModule.isCoordinatorMode()) {
-      return applyCoordinatorToolFilter(tools)
-    }
+  if (getCoordinatorModeModule().isCoordinatorMode()) {
+    return applyCoordinatorToolFilter(tools)
   }
 
   return tools

package/src/utils/udsClient.ts

@@ -0,0 +1,40 @@
+import net from 'net'
+import {
+  listAllLiveSessions as listLiveSessionsFromRegistry,
+  listLocalPeers as listPeersFromRegistry,
+} from './concurrentSessions.js'
+import { getPlatform, SUPPORTED_PLATFORMS } from './platform.js'
+
+export const listAllLiveSessions = listLiveSessionsFromRegistry
+export const listLocalPeers = listPeersFromRegistry
+
+export async function sendToUdsSocket(
+  socketPath: string,
+  message: string,
+): Promise<void> {
+  const platform = getPlatform()
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(
+      'Local UDS messaging is not supported on native windows in this phase.',
+    )
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    const client = net.createConnection(socketPath)
+    const timeout = setTimeout(() => {
+      client.destroy(new Error(`Timed out connecting to ${socketPath}`))
+    }, 3_000)
+
+    client.once('error', error => {
+      clearTimeout(timeout)
+      reject(error)
+    })
+    client.once('connect', () => {
+      client.end(message, 'utf8')
+    })
+    client.once('close', hadError => {
+      clearTimeout(timeout)
+      if (!hadError) resolve()
+    })
+  })
+}

package/src/utils/udsMessaging.ts

@@ -0,0 +1,98 @@
+import net from 'net'
+import { mkdir, unlink } from 'fs/promises'
+import { dirname, join } from 'path'
+import { tmpdir } from 'os'
+import { registerCleanup } from './cleanupRegistry.js'
+import { logForDebugging } from './debug.js'
+import { errorMessage } from './errors.js'
+import { getPlatform, SUPPORTED_PLATFORMS } from './platform.js'
+
+let activeSocketPath: string | undefined
+let server: net.Server | null = null
+let onEnqueue: (() => void) | undefined
+
+export function setOnEnqueue(callback: (() => void) | undefined): void {
+  onEnqueue = callback
+}
+
+export function getDefaultUdsSocketPath(): string {
+  return join(tmpdir(), 'deplyze-code', `uds-inbox-${process.pid}.sock`)
+}
+
+export function getUdsMessagingSocketPath(): string | undefined {
+  return activeSocketPath
+}
+
+async function closeServer(): Promise<void> {
+  const currentServer = server
+  const socketPath = activeSocketPath
+  server = null
+  activeSocketPath = undefined
+  delete process.env.CLAUDE_CODE_MESSAGING_SOCKET
+
+  if (currentServer) {
+    await new Promise<void>(resolve => {
+      currentServer.close(() => resolve())
+    }).catch(() => {})
+  }
+
+  if (socketPath) {
+    await unlink(socketPath).catch(() => {})
+  }
+}
+
+export async function startUdsMessaging(
+  socketPath: string,
+  _options?: { isExplicit?: boolean },
+): Promise<void> {
+  if (server || activeSocketPath) return
+
+  const platform = getPlatform()
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    delete process.env.CLAUDE_CODE_MESSAGING_SOCKET
+    return
+  }
+
+  try {
+    await mkdir(dirname(socketPath), { recursive: true })
+    await unlink(socketPath).catch(() => {})
+
+    const nextServer = net.createServer(socket => {
+      let payload = ''
+      socket.setEncoding('utf8')
+      socket.on('data', chunk => {
+        payload += chunk
+      })
+      socket.on('end', () => {
+        if (payload.trim().length > 0) {
+          onEnqueue?.()
+        }
+      })
+      socket.on('error', error => {
+        logForDebugging(
+          `[udsMessaging] socket error: ${errorMessage(error)}`,
+        )
+      })
+    })
+
+    await new Promise<void>((resolve, reject) => {
+      nextServer.once('error', reject)
+      nextServer.listen(socketPath, () => {
+        nextServer.off('error', reject)
+        resolve()
+      })
+    })
+
+    server = nextServer
+    activeSocketPath = socketPath
+    process.env.CLAUDE_CODE_MESSAGING_SOCKET = socketPath
+    registerCleanup(async () => {
+      await closeServer()
+    })
+  } catch (error) {
+    logForDebugging(
+      `[udsMessaging] failed to start socket ${socketPath}: ${errorMessage(error)}`,
+    )
+    await closeServer()
+  }
+}