@brimveyn/aimux 1.2.5 → 1.3.1

package/src/ipc/manager-protocol.ts

@@ -0,0 +1,396 @@
+import type {
+  ScrollIntent,
+  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
+        intents?: Record<string, ScrollIntent>
+      }
+    }
+  | {
+      id: string
+      type: 'resizeTab'
+      payload: {
+        sessionId: string
+        tabId: string
+        cols: number
+        rows: number
+        intent?: ScrollIntent
+      }
+    }
+  | {
+      id: string
+      type: 'scrollToBottom'
+      payload: { sessionId: string; tabId: string }
+    }
+  | {
+      id: string
+      type: 'scroll'
+      payload: { sessionId: string; tabId: string; deltaLines: number }
+    }
+  | {
+      id: string
+      type: 'reapplyScrollIntent'
+      payload: { sessionId: string; tabId: string; intent: ScrollIntent }
+    }
+  | { 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 isScrollIntent(value: unknown): value is ScrollIntent {
+  if (!isObjectRecord(value)) return false
+  if (value.kind === 'bottom') return true
+  if (value.kind === 'anchor') return isFiniteNumber(value.absoluteLine)
+  return false
+}
+
+function isScrollIntentRecord(value: unknown): value is Record<string, ScrollIntent> {
+  if (!isObjectRecord(value)) return false
+  return Object.values(value).every(isScrollIntent)
+}
+
+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')
+      assert(
+        value.payload.intents === undefined || isScrollIntentRecord(value.payload.intents),
+        'resizeClient.intents must be a scroll-intent record'
+      )
+      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')
+      assert(
+        value.payload.intent === undefined || isScrollIntent(value.payload.intent),
+        'resizeTab.intent must be a scroll intent'
+      )
+      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 'reapplyScrollIntent':
+      assert(isString(value.payload.sessionId), 'reapplyScrollIntent.sessionId must be a string')
+      assert(isString(value.payload.tabId), 'reapplyScrollIntent.tabId must be a string')
+      assert(
+        isScrollIntent(value.payload.intent),
+        'reapplyScrollIntent.intent must be a scroll intent'
+      )
+      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

@@ -1,4 +1,5 @@
 import type {
+  ScrollIntent,
   TabSession,
   TerminalModeState,
   TerminalSnapshot,
@@ -7,7 +8,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 +38,7 @@ export interface AttachResult {
 }
 
 export type ClientRequest =
+  | { id: string; type: 'hello'; payload: ProtocolHelloRequest }
   | { id: string; type: 'attach'; payload: AttachRequest }
   | {
       id: string
@@ -40,16 +55,30 @@ export type ClientRequest =
       }
     }
   | { id: string; type: 'write'; payload: { tabId: string; data: string } }
-  | { id: string; type: 'resizeClient'; payload: { cols: number; rows: number } }
-  | { id: string; type: 'resizeTab'; payload: { tabId: string; cols: number; rows: number } }
+  | {
+      id: string
+      type: 'resizeClient'
+      payload: { cols: number; rows: number; intents?: Record<string, ScrollIntent> }
+    }
+  | {
+      id: string
+      type: 'resizeTab'
+      payload: { tabId: string; cols: number; rows: number; intent?: ScrollIntent }
+    }
   | { id: string; type: 'scrollToBottom'; payload: { tabId: string } }
   | { id: string; type: 'scroll'; payload: { tabId: string; deltaLines: number } }
+  | {
+      id: string
+      type: 'reapplyScrollIntent'
+      payload: { tabId: string; intent: ScrollIntent }
+    }
   | { id: string; type: 'setActiveTab'; payload: { tabId: string | null } }
   | { id: string; type: 'closeTab'; payload: { tabId: string } }
   | { id: string; type: 'disposeAll'; payload: Record<string, never> }
   | { 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 } }
@@ -128,6 +157,18 @@ function isTerminalSnapshot(value: unknown): value is TerminalSnapshot {
   )
 }
 
+function isScrollIntent(value: unknown): value is ScrollIntent {
+  if (!isObjectRecord(value)) return false
+  if (value.kind === 'bottom') return true
+  if (value.kind === 'anchor') return isFiniteNumber(value.absoluteLine)
+  return false
+}
+
+function isScrollIntentRecord(value: unknown): value is Record<string, ScrollIntent> {
+  if (!isObjectRecord(value)) return false
+  return Object.values(value).every(isScrollIntent)
+}
+
 function isTerminalModeState(value: unknown): value is TerminalModeState {
   return (
     isObjectRecord(value) &&
@@ -143,6 +184,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 +229,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 +255,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')
@@ -225,11 +299,19 @@ export function parseClientRequest(value: unknown): ClientRequest {
     case 'resizeClient':
       assert(isFiniteNumber(value.payload.cols), 'resizeClient.cols must be a number')
       assert(isFiniteNumber(value.payload.rows), 'resizeClient.rows must be a number')
+      assert(
+        value.payload.intents === undefined || isScrollIntentRecord(value.payload.intents),
+        'resizeClient.intents must be a scroll-intent record'
+      )
       return value as ClientRequest
     case 'resizeTab':
       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')
+      assert(
+        value.payload.intent === undefined || isScrollIntent(value.payload.intent),
+        'resizeTab.intent must be a scroll intent'
+      )
       return value as ClientRequest
     case 'scroll':
       assert(isString(value.payload.tabId), 'scroll.tabId must be a string')
@@ -238,6 +320,13 @@ export function parseClientRequest(value: unknown): ClientRequest {
     case 'scrollToBottom':
       assert(isString(value.payload.tabId), 'scrollToBottom.tabId must be a string')
       return value as ClientRequest
+    case 'reapplyScrollIntent':
+      assert(isString(value.payload.tabId), 'reapplyScrollIntent.tabId must be a string')
+      assert(
+        isScrollIntent(value.payload.intent),
+        'reapplyScrollIntent.intent must be a scroll intent'
+      )
+      return value as ClientRequest
     case 'setActiveTab':
       assert(isNullableString(value.payload.tabId), 'setActiveTab.tabId must be a string or null')
       return value as ClientRequest
@@ -258,6 +347,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())
+}