@brimveyn/aimux 1.2.0 → 1.3.0

package/src/ipc/manager-protocol.ts

@@ -0,0 +1,347 @@
+import type {
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
+
+import { isWorkspaceSnapshotV1 } from '../state/validation'
+import {
+  getProcessVersion,
+  IpcProtocolError,
+  MessageDecoder,
+  negotiateProtocolVersion,
+} from './protocol'
+
+export const MANAGER_PROTOCOL_MIN_VERSION = 1
+export const MANAGER_PROTOCOL_VERSION = 1
+
+export interface ManagerHelloRequest {
+  minVersion: number
+  maxVersion: number
+}
+
+export interface ManagerHelloResult {
+  minVersion: number
+  maxVersion: number
+  processVersion: string
+  selectedVersion: number
+}
+
+export interface ManagerAttachRequest {
+  protocolVersion: number
+  sessionId: string
+  cols: number
+  rows: number
+  workspaceSnapshot?: WorkspaceSnapshotV1
+}
+
+export interface ManagerAttachResult {
+  protocolVersion: number
+  tabs: TabSession[]
+  activeTabId: string | null
+}
+
+export type ManagerRequest =
+  | { id: string; type: 'hello'; payload: ManagerHelloRequest }
+  | { id: string; type: 'attachSession'; payload: ManagerAttachRequest }
+  | {
+      id: string
+      type: 'createTab'
+      payload: {
+        sessionId: string
+        tabId: string
+        assistant: TabSession['assistant']
+        title: string
+        command: string
+        args?: string[]
+        cols: number
+        rows: number
+        cwd?: string
+      }
+    }
+  | { id: string; type: 'write'; payload: { sessionId: string; tabId: string; data: string } }
+  | { id: string; type: 'resizeClient'; payload: { sessionId: string; cols: number; rows: number } }
+  | {
+      id: string
+      type: 'resizeTab'
+      payload: { sessionId: string; tabId: string; cols: number; rows: number }
+    }
+  | {
+      id: string
+      type: 'scrollToBottom'
+      payload: { sessionId: string; tabId: string }
+    }
+  | {
+      id: string
+      type: 'scroll'
+      payload: { sessionId: string; tabId: string; deltaLines: number }
+    }
+  | { id: string; type: 'setActiveTab'; payload: { sessionId: string; tabId: string | null } }
+  | { id: string; type: 'closeTab'; payload: { sessionId: string; tabId: string } }
+  | { id: string; type: 'disposeSession'; payload: { sessionId: string } }
+  | { id: string; type: 'ping'; payload: Record<string, never> }
+
+export type ManagerResponse =
+  | { id: string; type: 'helloResult'; payload: ManagerHelloResult }
+  | { id: string; type: 'ok'; payload: Record<string, never> }
+  | { id: string; type: 'attachResult'; payload: ManagerAttachResult }
+  | { id: string; type: 'error'; payload: { message: string } }
+
+export type ManagerEvent =
+  | {
+      type: 'tabRender'
+      payload: {
+        sessionId: string
+        tabId: string
+        viewport: TerminalSnapshot
+        terminalModes: TerminalModeState
+      }
+    }
+  | { type: 'tabExit'; payload: { sessionId: string; tabId: string; exitCode: number } }
+  | { type: 'tabError'; payload: { sessionId: string; tabId: string; message: string } }
+
+export type ManagerMessage = ManagerRequest | ManagerResponse | ManagerEvent
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+function isString(value: unknown): value is string {
+  return typeof value === 'string'
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return value === null || isString(value)
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every(isString)
+}
+
+function isTerminalSpan(value: unknown): boolean {
+  return (
+    isObjectRecord(value) &&
+    isString(value.text) &&
+    (value.fg === undefined || isString(value.fg)) &&
+    (value.bg === undefined || isString(value.bg)) &&
+    (value.bold === undefined || typeof value.bold === 'boolean') &&
+    (value.italic === undefined || typeof value.italic === 'boolean') &&
+    (value.underline === undefined || typeof value.underline === 'boolean') &&
+    (value.cursor === undefined || typeof value.cursor === 'boolean')
+  )
+}
+
+function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
+  return (
+    isObjectRecord(value) &&
+    Array.isArray(value.lines) &&
+    value.lines.every(
+      (line) =>
+        isObjectRecord(line) && Array.isArray(line.spans) && line.spans.every(isTerminalSpan)
+    ) &&
+    isFiniteNumber(value.viewportY) &&
+    isFiniteNumber(value.baseY) &&
+    typeof value.cursorVisible === 'boolean'
+  )
+}
+
+function isTerminalModeState(value: unknown): value is TerminalModeState {
+  return (
+    isObjectRecord(value) &&
+    (value.mouseTrackingMode === 'none' ||
+      value.mouseTrackingMode === 'x10' ||
+      value.mouseTrackingMode === 'vt200' ||
+      value.mouseTrackingMode === 'drag' ||
+      value.mouseTrackingMode === 'any') &&
+    typeof value.sendFocusMode === 'boolean' &&
+    typeof value.alternateScrollMode === 'boolean' &&
+    typeof value.isAlternateBuffer === 'boolean' &&
+    typeof value.bracketedPasteMode === 'boolean'
+  )
+}
+
+function isAttachResult(value: unknown): value is ManagerAttachResult {
+  return (
+    isObjectRecord(value) &&
+    isFiniteNumber(value.protocolVersion) &&
+    Array.isArray(value.tabs) &&
+    value.tabs.every((tab) => isObjectRecord(tab) && isString(tab.id)) &&
+    isNullableString(value.activeTabId)
+  )
+}
+
+function isHelloResult(value: unknown): value is ManagerHelloResult {
+  return (
+    isObjectRecord(value) &&
+    isFiniteNumber(value.minVersion) &&
+    isFiniteNumber(value.maxVersion) &&
+    isFiniteNumber(value.selectedVersion) &&
+    isString(value.processVersion)
+  )
+}
+
+function assert(condition: boolean, message: string): asserts condition {
+  if (!condition) {
+    throw new IpcProtocolError(message)
+  }
+}
+
+export function selectManagerProtocolVersion(payload: ManagerHelloRequest): number | null {
+  return negotiateProtocolVersion(
+    payload.minVersion,
+    payload.maxVersion,
+    MANAGER_PROTOCOL_MIN_VERSION,
+    MANAGER_PROTOCOL_VERSION
+  )
+}
+
+export function createManagerHelloResult(selectedVersion: number): ManagerHelloResult {
+  return {
+    maxVersion: MANAGER_PROTOCOL_VERSION,
+    minVersion: MANAGER_PROTOCOL_MIN_VERSION,
+    processVersion: getProcessVersion(),
+    selectedVersion,
+  }
+}
+
+export function parseManagerRequest(value: unknown): ManagerRequest {
+  assert(isObjectRecord(value), 'IPC message must be an object')
+  assert(isString(value.id), 'IPC request id must be a string')
+  assert(isString(value.type), 'IPC request type must be a string')
+  assert(isObjectRecord(value.payload), 'IPC request payload must be an object')
+
+  switch (value.type) {
+    case 'hello':
+      assert(isFiniteNumber(value.payload.minVersion), 'hello.minVersion must be a number')
+      assert(isFiniteNumber(value.payload.maxVersion), 'hello.maxVersion must be a number')
+      return value as ManagerRequest
+    case 'attachSession':
+      assert(
+        isFiniteNumber(value.payload.protocolVersion),
+        'attachSession.protocolVersion must be a number'
+      )
+      assert(isString(value.payload.sessionId), 'attachSession.sessionId must be a string')
+      assert(isFiniteNumber(value.payload.cols), 'attachSession.cols must be a number')
+      assert(isFiniteNumber(value.payload.rows), 'attachSession.rows must be a number')
+      assert(
+        value.payload.workspaceSnapshot === undefined ||
+          isWorkspaceSnapshotV1(value.payload.workspaceSnapshot),
+        'attachSession.workspaceSnapshot must be a valid workspace snapshot'
+      )
+      return value as ManagerRequest
+    case 'createTab':
+      assert(isString(value.payload.sessionId), 'createTab.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'createTab.tabId must be a string')
+      assert(
+        isString(value.payload.assistant) && value.payload.assistant.length > 0,
+        'createTab.assistant must be a non-empty string'
+      )
+      assert(isString(value.payload.title), 'createTab.title must be a string')
+      assert(isString(value.payload.command), 'createTab.command must be a string')
+      assert(
+        value.payload.args === undefined || isStringArray(value.payload.args),
+        'createTab.args must be a string array'
+      )
+      assert(isFiniteNumber(value.payload.cols), 'createTab.cols must be a number')
+      assert(isFiniteNumber(value.payload.rows), 'createTab.rows must be a number')
+      assert(
+        value.payload.cwd === undefined || isString(value.payload.cwd),
+        'createTab.cwd must be a string'
+      )
+      return value as ManagerRequest
+    case 'write':
+      assert(isString(value.payload.sessionId), 'write.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'write.tabId must be a string')
+      assert(isString(value.payload.data), 'write.data must be a string')
+      return value as ManagerRequest
+    case 'resizeClient':
+      assert(isString(value.payload.sessionId), 'resizeClient.sessionId must be a string')
+      assert(isFiniteNumber(value.payload.cols), 'resizeClient.cols must be a number')
+      assert(isFiniteNumber(value.payload.rows), 'resizeClient.rows must be a number')
+      return value as ManagerRequest
+    case 'resizeTab':
+      assert(isString(value.payload.sessionId), 'resizeTab.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'resizeTab.tabId must be a string')
+      assert(isFiniteNumber(value.payload.cols), 'resizeTab.cols must be a number')
+      assert(isFiniteNumber(value.payload.rows), 'resizeTab.rows must be a number')
+      return value as ManagerRequest
+    case 'scroll':
+      assert(isString(value.payload.sessionId), 'scroll.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'scroll.tabId must be a string')
+      assert(isFiniteNumber(value.payload.deltaLines), 'scroll.deltaLines must be a number')
+      return value as ManagerRequest
+    case 'scrollToBottom':
+      assert(isString(value.payload.sessionId), 'scrollToBottom.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'scrollToBottom.tabId must be a string')
+      return value as ManagerRequest
+    case 'setActiveTab':
+      assert(isString(value.payload.sessionId), 'setActiveTab.sessionId must be a string')
+      assert(isNullableString(value.payload.tabId), 'setActiveTab.tabId must be a string or null')
+      return value as ManagerRequest
+    case 'closeTab':
+      assert(isString(value.payload.sessionId), 'closeTab.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'closeTab.tabId must be a string')
+      return value as ManagerRequest
+    case 'disposeSession':
+      assert(isString(value.payload.sessionId), 'disposeSession.sessionId must be a string')
+      return value as ManagerRequest
+    case 'ping':
+      return value as ManagerRequest
+    default:
+      throw new IpcProtocolError(`Unknown IPC request type: ${String(value.type)}`)
+  }
+}
+
+export function parseManagerMessage(value: unknown): ManagerResponse | ManagerEvent {
+  assert(isObjectRecord(value), 'IPC message must be an object')
+  assert(isString(value.type), 'IPC response type must be a string')
+  assert(isObjectRecord(value.payload), 'IPC response payload must be an object')
+
+  switch (value.type) {
+    case 'helloResult':
+      assert(isString(value.id), 'helloResult.id must be a string')
+      assert(isHelloResult(value.payload), 'helloResult.payload is invalid')
+      return value as ManagerResponse
+    case 'ok':
+      assert(isString(value.id), 'ok.id must be a string')
+      return value as ManagerResponse
+    case 'attachResult':
+      assert(isString(value.id), 'attachResult.id must be a string')
+      assert(isAttachResult(value.payload), 'attachResult.payload is invalid')
+      return value as ManagerResponse
+    case 'error':
+      assert(isString(value.id), 'error.id must be a string')
+      assert(isString(value.payload.message), 'error.message must be a string')
+      return value as ManagerResponse
+    case 'tabRender':
+      assert(isString(value.payload.sessionId), 'tabRender.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'tabRender.tabId must be a string')
+      assert(isTerminalSnapshot(value.payload.viewport), 'tabRender.viewport is invalid')
+      assert(isTerminalModeState(value.payload.terminalModes), 'tabRender.terminalModes is invalid')
+      return value as ManagerEvent
+    case 'tabExit':
+      assert(isString(value.payload.sessionId), 'tabExit.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'tabExit.tabId must be a string')
+      assert(isFiniteNumber(value.payload.exitCode), 'tabExit.exitCode must be a number')
+      return value as ManagerEvent
+    case 'tabError':
+      assert(isString(value.payload.sessionId), 'tabError.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'tabError.tabId must be a string')
+      assert(isString(value.payload.message), 'tabError.message must be a string')
+      return value as ManagerEvent
+    default:
+      throw new IpcProtocolError(`Unknown IPC response type: ${String(value.type)}`)
+  }
+}
+
+export function encodeManagerMessage(message: ManagerMessage): Buffer {
+  const payload = JSON.stringify(message)
+  return Buffer.from(`${Buffer.byteLength(payload, 'utf8')}\n${payload}`, 'utf8')
+}
+
+export { MessageDecoder }

package/src/ipc/protocol.ts

@@ -7,7 +7,20 @@ import type {
 
 import { isWorkspaceSnapshotV1 } from '../state/validation'
 
-export const IPC_PROTOCOL_VERSION = 1
+export const IPC_PROTOCOL_MIN_VERSION = 2
+export const IPC_PROTOCOL_VERSION = 2
+
+export interface ProtocolHelloRequest {
+  minVersion: number
+  maxVersion: number
+}
+
+export interface ProtocolHelloResult {
+  minVersion: number
+  maxVersion: number
+  processVersion: string
+  selectedVersion: number
+}
 
 export interface AttachRequest {
   protocolVersion: number
@@ -24,6 +37,7 @@ export interface AttachResult {
 }
 
 export type ClientRequest =
+  | { id: string; type: 'hello'; payload: ProtocolHelloRequest }
   | { id: string; type: 'attach'; payload: AttachRequest }
   | {
       id: string
@@ -50,6 +64,7 @@ export type ClientRequest =
   | { id: string; type: 'ping'; payload: Record<string, never> }
 
 export type ServerResponse =
+  | { id: string; type: 'helloResult'; payload: ProtocolHelloResult }
   | { id: string; type: 'ok'; payload: Record<string, never> }
   | { id: string; type: 'attachResult'; payload: AttachResult }
   | { id: string; type: 'error'; payload: { message: string } }
@@ -143,6 +158,16 @@ function isTerminalModeState(value: unknown): value is TerminalModeState {
   )
 }
 
+function isProtocolHelloResult(value: unknown): value is ProtocolHelloResult {
+  return (
+    isObjectRecord(value) &&
+    isFiniteNumber(value.minVersion) &&
+    isFiniteNumber(value.maxVersion) &&
+    isFiniteNumber(value.selectedVersion) &&
+    isString(value.processVersion)
+  )
+}
+
 function isAttachResult(value: unknown): value is AttachResult {
   return (
     isObjectRecord(value) &&
@@ -178,6 +203,25 @@ function assert(condition: boolean, message: string): asserts condition {
   }
 }
 
+export function negotiateProtocolVersion(
+  clientMinVersion: number,
+  clientMaxVersion: number,
+  serverMinVersion: number,
+  serverMaxVersion: number
+): number | null {
+  const minVersion = Math.max(clientMinVersion, serverMinVersion)
+  const maxVersion = Math.min(clientMaxVersion, serverMaxVersion)
+  if (minVersion > maxVersion) {
+    return null
+  }
+
+  return maxVersion
+}
+
+export function getProcessVersion(): string {
+  return Bun.version
+}
+
 export function parseClientRequest(value: unknown): ClientRequest {
   assert(isObjectRecord(value), 'IPC message must be an object')
   assert(isString(value.id), 'IPC request id must be a string')
@@ -185,10 +229,14 @@ export function parseClientRequest(value: unknown): ClientRequest {
   assert(isObjectRecord(value.payload), 'IPC request payload must be an object')
 
   switch (value.type) {
+    case 'hello':
+      assert(isFiniteNumber(value.payload.minVersion), 'hello.minVersion must be a number')
+      assert(isFiniteNumber(value.payload.maxVersion), 'hello.maxVersion must be a number')
+      return value as ClientRequest
     case 'attach':
       assert(
-        value.payload.protocolVersion === IPC_PROTOCOL_VERSION,
-        `attach.protocolVersion must be ${IPC_PROTOCOL_VERSION}`
+        isFiniteNumber(value.payload.protocolVersion),
+        'attach.protocolVersion must be a number'
       )
       assert(isString(value.payload.sessionId), 'attach.sessionId must be a string')
       assert(isFiniteNumber(value.payload.cols), 'attach.cols must be a number')
@@ -258,6 +306,10 @@ export function parseServerMessage(value: unknown): ServerResponse | ServerEvent
   assert(isObjectRecord(value.payload), 'IPC response payload must be an object')
 
   switch (value.type) {
+    case 'helloResult':
+      assert(isString(value.id), 'helloResult.id must be a string')
+      assert(isProtocolHelloResult(value.payload), 'helloResult.payload is invalid')
+      return value as ServerResponse
     case 'ok':
       assert(isString(value.id), 'ok.id must be a string')
       return value as ServerResponse

package/src/platform/daemon-control.ts

@@ -1,12 +1,12 @@
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-import { getDaemonSocketPath } from '../daemon/runtime-paths'
+import { getIpcDaemonSocketPath, getTerminalManagerSocketPath } from '../daemon/runtime-paths'
 import { logDebug } from '../debug/input-log'
 
 const ENTRY_POINT = resolve(import.meta.dir, '..', 'index.tsx')
 
-export async function findDaemonPid(socketPath: string): Promise<number | null> {
+export async function findSocketProcessPid(socketPath: string): Promise<number | null> {
   try {
     const proc = Bun.spawn(['lsof', '-t', socketPath], { stderr: 'ignore', stdout: 'pipe' })
     const text = await new Response(proc.stdout).text()
@@ -21,7 +21,19 @@ export async function findDaemonPid(socketPath: string): Promise<number | null>
   }
 }
 
-export async function killDaemon(pid: number): Promise<void> {
+export async function findDaemonPid(socketPath: string): Promise<number | null> {
+  return findSocketProcessPid(socketPath)
+}
+
+export async function findIpcDaemonPid(): Promise<number | null> {
+  return findSocketProcessPid(getIpcDaemonSocketPath())
+}
+
+export async function findTerminalManagerPid(): Promise<number | null> {
+  return findSocketProcessPid(getTerminalManagerSocketPath())
+}
+
+export async function killProcess(pid: number): Promise<void> {
   process.kill(pid, 'SIGTERM')
 
   const deadline = Date.now() + 3_000
@@ -41,16 +53,12 @@ export async function killDaemon(pid: number): Promise<void> {
   }
 }
 
-export async function spawnDetachedDaemon(): Promise<boolean> {
-  Bun.spawn([process.execPath, 'run', ENTRY_POINT, 'daemon'], {
-    detached: true,
-    stderr: 'ignore',
-    stdin: 'ignore',
-    stdout: 'ignore',
-  }).unref()
+export async function killDaemon(pid: number): Promise<void> {
+  await killProcess(pid)
+}
 
+async function waitForSocket(socketPath: string): Promise<boolean> {
   const deadline = Date.now() + 2_000
-  const socketPath = getDaemonSocketPath()
   while (Date.now() < deadline) {
     if (existsSync(socketPath)) {
       return true
@@ -60,3 +68,26 @@ export async function spawnDetachedDaemon(): Promise<boolean> {
 
   return false
 }
+
+async function spawnDetachedProcess(command: 'daemon' | 'terminal-manager', socketPath: string) {
+  Bun.spawn([process.execPath, 'run', ENTRY_POINT, command], {
+    detached: true,
+    stderr: 'ignore',
+    stdin: 'ignore',
+    stdout: 'ignore',
+  }).unref()
+
+  return waitForSocket(socketPath)
+}
+
+export async function spawnDetachedDaemon(): Promise<boolean> {
+  return spawnDetachedProcess('daemon', getIpcDaemonSocketPath())
+}
+
+export async function spawnDetachedIpcDaemon(): Promise<boolean> {
+  return spawnDetachedDaemon()
+}
+
+export async function spawnDetachedTerminalManager(): Promise<boolean> {
+  return spawnDetachedProcess('terminal-manager', getTerminalManagerSocketPath())
+}

package/src/profile-paths.ts

@@ -0,0 +1,27 @@
+import { join } from 'node:path'
+
+export const DEFAULT_PROFILE = 'default'
+
+function sanitizeProfile(profile: string): string {
+  const trimmed = profile.trim().toLowerCase()
+  const normalized = trimmed.replace(/[^a-z0-9._-]+/g, '-')
+  const collapsed = normalized.replace(/-+/g, '-').replace(/^-|-$/g, '')
+  return collapsed || DEFAULT_PROFILE
+}
+
+export function getProfileName(): string {
+  const configured = process.env.AIMUX_PROFILE ?? process.env.AIMUX_RUNTIME_PROFILE
+  if (!configured) {
+    return DEFAULT_PROFILE
+  }
+
+  return sanitizeProfile(configured)
+}
+
+export function getConfigProfilesRootDir(): string {
+  return join(process.env.HOME ?? '~', '.config', 'aimux')
+}
+
+export function getProfileConfigDir(): string {
+  return join(getConfigProfilesRootDir(), getProfileName())
+}

package/src/pty/pty-manager.ts

@@ -4,6 +4,7 @@ import { EventEmitter } from 'node:events'
 
 import type { TerminalModeState, TerminalSnapshot } from '../state/types'
 
+import { logDebug } from '../debug/input-log'
 import { areTerminalSnapshotsEqual, snapshotTerminal } from './terminal-snapshot'
 
 type PtyManagerEvents = {
@@ -99,6 +100,12 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
 
     session.lastSnapshot = nextSnapshot
     session.lastTerminalModes = nextTerminalModes
+    logDebug('ptyManager.render', {
+      isAlternateBuffer: nextTerminalModes.isAlternateBuffer,
+      lines: nextSnapshot.lines.length,
+      tabId: session.tabId,
+      viewportY: nextSnapshot.viewportY,
+    })
     this.emit('render', session.tabId, nextSnapshot, nextTerminalModes)
   }
 
@@ -111,6 +118,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     this.sessions.delete(session.tabId)
     this.emitRenderIfChanged(session)
     session.emulator.dispose()
+    logDebug('ptyManager.finalize', { exitCode, tabId: session.tabId })
     this.emit('exit', session.tabId, exitCode)
   }
 
@@ -123,6 +131,14 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
     cwd?: string
   }): void {
     this.disposeSession(options.tabId)
+    logDebug('ptyManager.create.start', {
+      args: options.args ?? [],
+      cols: options.cols,
+      command: options.command,
+      cwd: options.cwd ?? process.cwd(),
+      rows: options.rows,
+      tabId: options.tabId,
+    })
 
     try {
       const emulator = new XTerm({
@@ -157,6 +173,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       }
 
       pty.onData((data) => {
+        logDebug('ptyManager.data', {
+          byteLength: Buffer.byteLength(data, 'utf8'),
+          pendingWrites: session.pendingWrites,
+          tabId: options.tabId,
+        })
         const trackedModes = trackPrivateModes(
           session.alternateScrollMode,
           session.cursorVisible,
@@ -178,6 +199,7 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       })
 
       pty.onExit(({ exitCode }) => {
+        logDebug('ptyManager.exit', { exitCode, tabId: options.tabId })
         const current = this.sessions.get(options.tabId)
         if (!current || current.pty !== pty) {
           return
@@ -192,9 +214,11 @@ export class PtyManager extends EventEmitter<PtyManagerEvents> {
       })
 
       this.sessions.set(options.tabId, session)
+      logDebug('ptyManager.create.success', { tabId: options.tabId })
       this.emitRenderIfChanged(session)
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
+      logDebug('ptyManager.create.error', { error: message, tabId: options.tabId })
       this.emit('error', options.tabId, `Failed to start session: ${message}`)
     }
   }

package/src/restart-daemon.ts

@@ -1,28 +1,28 @@
 import { getDaemonSocketPath, removeDaemonSocketIfExists } from './daemon/runtime-paths'
-import { findDaemonPid, killDaemon, spawnDetachedDaemon } from './platform/daemon-control'
+import { findIpcDaemonPid, killProcess, spawnDetachedIpcDaemon } from './platform/daemon-control'
 
 export async function runRestartDaemon(): Promise<number> {
   const socketPath = getDaemonSocketPath()
-  const pid = await findDaemonPid(socketPath)
+  const pid = await findIpcDaemonPid()
 
   if (pid !== null) {
-    process.stdout.write(`Stopping daemon (pid ${pid})...\n`)
-    await killDaemon(pid)
-    process.stdout.write('Daemon stopped.\n')
+    process.stdout.write(`Stopping IPC daemon (pid ${pid})...\n`)
+    await killProcess(pid)
+    process.stdout.write('IPC daemon stopped.\n')
   } else {
-    process.stdout.write('No running daemon found.\n')
+    process.stdout.write('No running IPC daemon found.\n')
   }
 
   removeDaemonSocketIfExists()
 
-  process.stdout.write('Starting daemon...\n')
-  const ok = await spawnDetachedDaemon()
+  process.stdout.write('Starting IPC daemon...\n')
+  const ok = await spawnDetachedIpcDaemon()
 
   if (ok) {
-    process.stdout.write('Daemon started.\n')
+    process.stdout.write(`IPC daemon started on ${socketPath}.\n`)
     return 0
   }
 
-  process.stderr.write('Failed to start daemon.\n')
+  process.stderr.write('Failed to start IPC daemon.\n')
   return 1
 }