@brimveyn/aimux 1.1.0

package/src/input/raw-input-handler.ts

@@ -0,0 +1,191 @@
+import type { FocusMode } from '../state/types'
+
+import { logInputDebug } from '../debug/input-log'
+import { type KeyChord, rawSequenceToChord } from './keymap/key-chord'
+import { BRACKETED_PASTE_END, BRACKETED_PASTE_START, buildPtyPastePayload } from './paste'
+
+const ESC = '\x1b'
+const KITTY_CTRL_RE = new RegExp(`^${ESC}\\[(\\d+);(\\d+)u$`)
+const KITTY_MOD_SUPER = 8
+const KITTY_MOD_HYPER = 16
+const KITTY_MOD_META = 32
+const KITTY_HOST_MOD_MASK = KITTY_MOD_SUPER | KITTY_MOD_HYPER | KITTY_MOD_META
+
+function normalizeControlSequence(sequence: string): string | null {
+  const match = KITTY_CTRL_RE.exec(sequence)
+  if (!match) {
+    return sequence
+  }
+
+  const codePoint = Number(match[1])
+  const modifiers = Number(match[2]) - 1
+
+  if ((modifiers & KITTY_HOST_MOD_MASK) !== 0) {
+    return null
+  }
+
+  const hasCtrl = (modifiers & 4) !== 0
+  const hasAlt = (modifiers & 2) !== 0
+
+  if (!hasCtrl || hasAlt) {
+    return sequence
+  }
+
+  if ((codePoint >= 65 && codePoint <= 90) || (codePoint >= 97 && codePoint <= 122)) {
+    return String.fromCharCode(codePoint & 0x1f)
+  }
+
+  switch (codePoint) {
+    case 32:
+    case 50:
+    case 64:
+      return '\x00'
+    case 51:
+    case 91:
+      return '\x1b'
+    case 52:
+    case 92:
+      return '\x1c'
+    case 53:
+    case 93:
+      return '\x1d'
+    case 54:
+    case 94:
+      return '\x1e'
+    case 47:
+    case 55:
+    case 95:
+      return '\x1f'
+    case 56:
+    case 63:
+      return '\x7f'
+    default:
+      return sequence
+  }
+}
+
+export interface TerminalContentOrigin {
+  /** 0-based screen column of the first content cell */
+  x: number
+  /** 0-based screen row of the first content cell */
+  y: number
+  /** PTY column count */
+  cols: number
+  /** PTY row count */
+  rows: number
+}
+
+export function createRawInputHandler(deps: {
+  getFocusMode: () => FocusMode
+  getActiveTabId: () => string | null
+  getBracketedPasteModeEnabled: () => boolean
+  writeToPty: (tabId: string, data: string) => void
+  /**
+   * Dispatch a configured terminal-input shortcut.
+   * Returns true if the chord was consumed by the keymap, false otherwise.
+   */
+  handleTerminalShortcut: (chord: KeyChord) => boolean
+}): (sequence: string) => boolean {
+  let bracketedPasteBuffer: string | null = null
+
+  function flushPaste(tabId: string, payload: string): void {
+    logInputDebug('raw.flushPaste', {
+      bracketedPasteModeEnabled: deps.getBracketedPasteModeEnabled(),
+      payloadLength: payload.length,
+      payloadPreview: payload.slice(0, 120),
+      tabId,
+    })
+    deps.writeToPty(tabId, buildPtyPastePayload(payload, deps.getBracketedPasteModeEnabled()))
+  }
+
+  function handleTerminalShortcut(sequence: string): boolean {
+    const chord = rawSequenceToChord(sequence)
+    if (chord === null) return false
+    return deps.handleTerminalShortcut(chord)
+  }
+
+  function handleSequence(tabId: string, sequence: string): boolean {
+    if (sequence.length === 0) {
+      return true
+    }
+
+    if (bracketedPasteBuffer !== null) {
+      logInputDebug('raw.collectPasteChunk', {
+        chunkLength: sequence.length,
+        chunkPreview: sequence.slice(0, 120),
+        tabId,
+      })
+      const endIndex = sequence.indexOf(BRACKETED_PASTE_END)
+      if (endIndex === -1) {
+        bracketedPasteBuffer += sequence
+        return true
+      }
+
+      bracketedPasteBuffer += sequence.slice(0, endIndex)
+      flushPaste(tabId, bracketedPasteBuffer)
+      bracketedPasteBuffer = null
+      return handleSequence(tabId, sequence.slice(endIndex + BRACKETED_PASTE_END.length))
+    }
+
+    const startIndex = sequence.indexOf(BRACKETED_PASTE_START)
+    if (startIndex !== -1) {
+      logInputDebug('raw.detectBracketedPasteStart', {
+        sequenceLength: sequence.length,
+        sequencePreview: sequence.slice(0, 120),
+        tabId,
+      })
+      if (!handleSequence(tabId, sequence.slice(0, startIndex))) {
+        return false
+      }
+
+      const afterStart = sequence.slice(startIndex + BRACKETED_PASTE_START.length)
+      const endIndex = afterStart.indexOf(BRACKETED_PASTE_END)
+      if (endIndex === -1) {
+        bracketedPasteBuffer = afterStart
+        return true
+      }
+
+      flushPaste(tabId, afterStart.slice(0, endIndex))
+      return handleSequence(tabId, afterStart.slice(endIndex + BRACKETED_PASTE_END.length))
+    }
+
+    if (handleTerminalShortcut(sequence)) {
+      return true
+    }
+
+    const normalized = normalizeControlSequence(sequence)
+    if (normalized === null) {
+      logInputDebug('raw.swallowHostModifier', {
+        sequencePreview: sequence.slice(0, 40),
+        tabId,
+      })
+      return true
+    }
+
+    deps.writeToPty(tabId, normalized)
+    return true
+  }
+
+  return (sequence: string): boolean => {
+    if (deps.getFocusMode() !== 'terminal-input') {
+      return false
+    }
+
+    logInputDebug('raw.sequence', {
+      activeTabId: deps.getActiveTabId(),
+      sequenceLength: sequence.length,
+      sequencePreview: sequence.slice(0, 120),
+    })
+
+    if (handleTerminalShortcut(sequence)) {
+      return true
+    }
+
+    const activeTabId = deps.getActiveTabId()
+    if (!activeTabId) {
+      return false
+    }
+
+    return handleSequence(activeTabId, sequence)
+  }
+}

package/src/input/terminal-text-extraction.ts

@@ -0,0 +1,78 @@
+import type { TerminalLine } from '../state/types'
+
+export function getLineText(line: TerminalLine): string {
+  return line.spans.map((span) => span.text).join('')
+}
+
+/**
+ * Extract text from a range of terminal lines as a single string.
+ *
+ * Multi-row selections are lossy: trailing `[ \t]+` is stripped from each
+ * joined segment to drop the viewport padding the snapshot layer fills blank
+ * cells with. Without this, shell line continuations (`\` followed by padding
+ * spaces then `\n`) paste as escaped-space sequences instead of continuations.
+ *
+ * Single-row selections are returned verbatim — trailing spaces the user
+ * explicitly dragged over are preserved.
+ */
+export function extractStreamText(
+  lines: TerminalLine[],
+  startRow: number,
+  startCol: number,
+  endRow: number,
+  endCol: number
+): string {
+  if (startRow > endRow || (startRow === endRow && startCol > endCol)) {
+    ;[startRow, endRow] = [endRow, startRow]
+    ;[startCol, endCol] = [endCol, startCol]
+  }
+
+  const clampedStart = Math.max(0, startRow)
+  const clampedEnd = Math.min(lines.length - 1, endRow)
+  const parts: string[] = []
+
+  for (let row = clampedStart; row <= clampedEnd; row++) {
+    const text = getLineText(lines[row] as TerminalLine)
+    if (row === startRow && row === endRow) {
+      parts.push(text.slice(Math.max(0, startCol), Math.max(0, endCol)))
+    } else if (row === startRow) {
+      parts.push(rtrim(text.slice(Math.max(0, startCol))))
+    } else if (row === endRow) {
+      parts.push(rtrim(text.slice(0, Math.max(0, endCol))))
+    } else {
+      parts.push(rtrim(text))
+    }
+  }
+
+  return parts.join('\n')
+}
+
+function rtrim(text: string): string {
+  return text.replace(/[ \t]+$/, '')
+}
+
+export function getWordAtColumn(
+  lineText: string,
+  column: number
+): { text: string; startCol: number; endCol: number } {
+  if (column < 0 || column >= lineText.length) {
+    return { endCol: column, startCol: column, text: '' }
+  }
+
+  const ch = lineText[column]
+  if (!ch || !/\S/.test(ch)) {
+    return { endCol: column, startCol: column, text: '' }
+  }
+
+  let startCol = column
+  while (startCol > 0 && /\S/.test(lineText[startCol - 1] as string)) {
+    startCol--
+  }
+
+  let endCol = column
+  while (endCol < lineText.length && /\S/.test(lineText[endCol] as string)) {
+    endCol++
+  }
+
+  return { endCol, startCol, text: lineText.slice(startCol, endCol) }
+}

package/src/ipc/protocol.ts

@@ -0,0 +1,341 @@
+import type {
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceSnapshotV1,
+} from '../state/types'
+
+import { isWorkspaceSnapshotV1 } from '../state/validation'
+
+export const IPC_PROTOCOL_VERSION = 1
+
+export interface AttachRequest {
+  protocolVersion: number
+  sessionId: string
+  cols: number
+  rows: number
+  workspaceSnapshot?: WorkspaceSnapshotV1
+}
+
+export interface AttachResult {
+  protocolVersion: number
+  tabs: TabSession[]
+  activeTabId: string | null
+}
+
+export type ClientRequest =
+  | { id: string; type: 'attach'; payload: AttachRequest }
+  | {
+      id: string
+      type: 'createTab'
+      payload: {
+        tabId: string
+        assistant: TabSession['assistant']
+        title: string
+        command: string
+        args?: string[]
+        cols: number
+        rows: number
+        cwd?: string
+      }
+    }
+  | { 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: 'scrollToBottom'; payload: { tabId: string } }
+  | { id: string; type: 'scroll'; payload: { tabId: string; deltaLines: number } }
+  | { 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: 'ok'; payload: Record<string, never> }
+  | { id: string; type: 'attachResult'; payload: AttachResult }
+  | { id: string; type: 'error'; payload: { message: string } }
+
+export type ServerEvent =
+  | {
+      type: 'tabRender'
+      payload: { tabId: string; viewport: TerminalSnapshot; terminalModes: TerminalModeState }
+    }
+  | { type: 'tabExit'; payload: { tabId: string; exitCode: number } }
+  | { type: 'tabError'; payload: { tabId: string; message: string } }
+
+export type IpcMessage = ClientRequest | ServerResponse | ServerEvent
+
+export class IpcProtocolError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'IpcProtocolError'
+  }
+}
+
+export class ProtocolMismatchError extends Error {
+  constructor(
+    public readonly clientVersion: number,
+    public readonly daemonVersion: number
+  ) {
+    super(`Protocol mismatch: client v${clientVersion}, daemon v${daemonVersion}`)
+    this.name = 'ProtocolMismatchError'
+  }
+}
+
+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 AttachResult {
+  return (
+    isObjectRecord(value) &&
+    isFiniteNumber(value.protocolVersion) &&
+    Array.isArray(value.tabs) &&
+    value.tabs.every(
+      (tab) =>
+        isObjectRecord(tab) &&
+        isString(tab.id) &&
+        isString(tab.assistant) &&
+        tab.assistant.length > 0 &&
+        isString(tab.title) &&
+        (tab.status === 'starting' ||
+          tab.status === 'running' ||
+          tab.status === 'disconnected' ||
+          tab.status === 'exited' ||
+          tab.status === 'error') &&
+        (tab.activity === undefined || tab.activity === 'busy' || tab.activity === 'idle') &&
+        isString(tab.buffer) &&
+        isTerminalModeState(tab.terminalModes) &&
+        isString(tab.command) &&
+        (tab.viewport === undefined || isTerminalSnapshot(tab.viewport)) &&
+        (tab.errorMessage === undefined || isString(tab.errorMessage)) &&
+        (tab.exitCode === undefined || isFiniteNumber(tab.exitCode))
+    ) &&
+    isNullableString(value.activeTabId)
+  )
+}
+
+function assert(condition: boolean, message: string): asserts condition {
+  if (!condition) {
+    throw new IpcProtocolError(message)
+  }
+}
+
+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')
+  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 'attach':
+      assert(
+        value.payload.protocolVersion === IPC_PROTOCOL_VERSION,
+        `attach.protocolVersion must be ${IPC_PROTOCOL_VERSION}`
+      )
+      assert(isString(value.payload.sessionId), 'attach.sessionId must be a string')
+      assert(isFiniteNumber(value.payload.cols), 'attach.cols must be a number')
+      assert(isFiniteNumber(value.payload.rows), 'attach.rows must be a number')
+      assert(
+        value.payload.workspaceSnapshot === undefined ||
+          isWorkspaceSnapshotV1(value.payload.workspaceSnapshot),
+        'attach.workspaceSnapshot must be a valid workspace snapshot'
+      )
+      return value as ClientRequest
+    case 'createTab':
+      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 ClientRequest
+    case 'write':
+      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 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')
+      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')
+      return value as ClientRequest
+    case 'scroll':
+      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 ClientRequest
+    case 'scrollToBottom':
+      assert(isString(value.payload.tabId), 'scrollToBottom.tabId must be a string')
+      return value as ClientRequest
+    case 'setActiveTab':
+      assert(isNullableString(value.payload.tabId), 'setActiveTab.tabId must be a string or null')
+      return value as ClientRequest
+    case 'closeTab':
+      assert(isString(value.payload.tabId), 'closeTab.tabId must be a string')
+      return value as ClientRequest
+    case 'disposeAll':
+    case 'ping':
+      return value as ClientRequest
+    default:
+      throw new IpcProtocolError(`Unknown IPC request type: ${String(value.type)}`)
+  }
+}
+
+export function parseServerMessage(value: unknown): ServerResponse | ServerEvent {
+  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 'ok':
+      assert(isString(value.id), 'ok.id must be a string')
+      return value as ServerResponse
+    case 'attachResult':
+      assert(isString(value.id), 'attachResult.id must be a string')
+      assert(isAttachResult(value.payload), 'attachResult.payload is invalid')
+      return value as ServerResponse
+    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 ServerResponse
+    case 'tabRender':
+      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 ServerEvent
+    case 'tabExit':
+      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 ServerEvent
+    case 'tabError':
+      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 ServerEvent
+    default:
+      throw new IpcProtocolError(`Unknown IPC response type: ${String(value.type)}`)
+  }
+}
+
+export function encodeMessage(message: IpcMessage): Buffer {
+  const payload = JSON.stringify(message)
+  return Buffer.from(`${Buffer.byteLength(payload, 'utf8')}\n${payload}`, 'utf8')
+}
+
+export class MessageDecoder<TMessage = IpcMessage> {
+  private buffer = Buffer.alloc(0)
+  private expectedPayloadBytes: number | null = null
+
+  constructor(
+    private readonly parseMessage: (value: unknown) => TMessage = (value) => value as TMessage
+  ) {}
+
+  push(chunk: string | Uint8Array): TMessage[] {
+    const nextChunk = typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : Buffer.from(chunk)
+    this.buffer = this.buffer.length === 0 ? nextChunk : Buffer.concat([this.buffer, nextChunk])
+
+    const messages: TMessage[] = []
+    while (true) {
+      if (this.expectedPayloadBytes === null) {
+        const separatorIndex = this.buffer.indexOf(0x0a)
+        if (separatorIndex === -1) {
+          break
+        }
+
+        const header = this.buffer.subarray(0, separatorIndex).toString('utf8')
+        if (!/^\d+$/.test(header)) {
+          throw new Error(`Invalid IPC frame header: ${JSON.stringify(header)}`)
+        }
+
+        this.expectedPayloadBytes = Number.parseInt(header, 10)
+        this.buffer = this.buffer.subarray(separatorIndex + 1)
+      }
+
+      if (this.buffer.length < this.expectedPayloadBytes) {
+        break
+      }
+
+      const payload = this.buffer.subarray(0, this.expectedPayloadBytes).toString('utf8')
+      this.buffer = this.buffer.subarray(this.expectedPayloadBytes)
+      this.expectedPayloadBytes = null
+      messages.push(this.parseMessage(JSON.parse(payload)))
+    }
+
+    return messages
+  }
+
+  reset(): void {
+    this.buffer = Buffer.alloc(0)
+    this.expectedPayloadBytes = null
+  }
+}

package/src/platform/clipboard.ts

@@ -0,0 +1,13 @@
+import { logDebug } from '../debug/input-log'
+
+export function copyToSystemClipboard(text: string): void {
+  try {
+    const proc = Bun.spawn(['pbcopy'], { stdin: 'pipe' })
+    proc.stdin.write(text)
+    proc.stdin.end()
+  } catch (error) {
+    logDebug('platform.clipboard.copyError', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}

package/src/platform/daemon-control.ts

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { getDaemonSocketPath } 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> {
+  try {
+    const proc = Bun.spawn(['lsof', '-t', socketPath], { stderr: 'ignore', stdout: 'pipe' })
+    const text = await new Response(proc.stdout).text()
+    const pid = parseInt(text.trim(), 10)
+    return Number.isFinite(pid) ? pid : null
+  } catch (error) {
+    logDebug('platform.daemon.findPidError', {
+      error: error instanceof Error ? error.message : String(error),
+      socketPath,
+    })
+    return null
+  }
+}
+
+export async function killDaemon(pid: number): Promise<void> {
+  process.kill(pid, 'SIGTERM')
+
+  const deadline = Date.now() + 3_000
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0)
+    } catch {
+      return
+    }
+    await Bun.sleep(50)
+  }
+
+  try {
+    process.kill(pid, 'SIGKILL')
+  } catch {
+    // already gone
+  }
+}
+
+export async function spawnDetachedDaemon(): Promise<boolean> {
+  Bun.spawn([process.execPath, 'run', ENTRY_POINT, 'daemon'], {
+    detached: true,
+    stderr: 'ignore',
+    stdin: 'ignore',
+    stdout: 'ignore',
+  }).unref()
+
+  const deadline = Date.now() + 2_000
+  const socketPath = getDaemonSocketPath()
+  while (Date.now() < deadline) {
+    if (existsSync(socketPath)) {
+      return true
+    }
+    await Bun.sleep(50)
+  }
+
+  return false
+}

package/src/platform/id.ts

@@ -0,0 +1,7 @@
+const RANDOM_ID_START_INDEX = 2
+const RANDOM_ID_END_INDEX = 8
+
+export function createPrefixedId(prefix: string): string {
+  const suffix = Math.random().toString(36).slice(RANDOM_ID_START_INDEX, RANDOM_ID_END_INDEX)
+  return `${prefix}-${Date.now()}-${suffix}`
+}