Function sendToUdsSocket

src/utils/udsClient.ts:206–265

(
  targetSocketPath: string,
  message: string | Record<string, unknown>,
  timeoutMs = 5000,
)

 * used by SendMessageTool for `uds:<path>` addresses.
 */
export async function sendToUdsSocket(
  targetSocketPath: string,
  message: string | Record<string, unknown>,
  timeoutMs = 5000,
): Promise<void> {
  const { parseUdsTarget } = await import('./udsMessaging.js')
  const target = parseUdsTarget(targetSocketPath)
  const authToken = await findAuthTokenForSocketPath(target.socketPath)
  if (!authToken) {
    throw new Error(`No auth token found for peer at ${target.socketPath}`)
  }

  const data = typeof message === 'string' ? message : jsonStringify(message)
  const udsMsg: UdsMessage = {
    type: 'text',
    data,
    ts: new Date().toISOString(),
  }

  // Lazily import to avoid circular dep at module-load time
  const { getUdsMessagingSocketPath } = await import('./udsMessaging.js')
  udsMsg.from = getUdsMessagingSocketPath()

  return new Promise<void>((resolve, reject) => {
    let settled = false
    let conn: ReturnType<typeof createConnection>
    const finish = (error?: Error): void => {
      if (settled) return
      settled = true
      if (error) {
        conn.destroy(error)
        reject(error)
      } else {
        conn.end()
        resolve()
      }
    }

    conn = createConnection(target.socketPath, () => {
      udsMsg.meta = { ...udsMsg.meta, authToken }
      conn.write(jsonStringify(udsMsg) + '\n', err => {
        if (err) finish(err)
      })
    })
    attachUdsResponseReader(conn, {
      maxFrameBytes: MAX_UDS_FRAME_BYTES,
      onSettled: finish,
      formatSocketError: err =>
        new UdsPeerConnectionError(target.socketPath, err),
    })
    conn.setTimeout(timeoutMs, () => {
      finish(
        new UdsPeerConnectionError(
          target.socketPath,
          new Error('Connection timed out'),
        ),
      )
    })