@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/internals/plugins/pty/plugin.ts

@@ -1,28 +0,0 @@
-import type { PluginContext, PluginResult } from './types'
-import { initManager, manager } from './pty/manager'
-import { initPermissions } from './pty/permissions'
-import { ptySpawn } from './pty/tools/spawn'
-import { ptyWrite } from './pty/tools/write'
-import { ptyRead } from './pty/tools/read'
-import { ptyList } from './pty/tools/list'
-import { ptyKill } from './pty/tools/kill'
-
-export const PTYPlugin = async ({ client, directory }: PluginContext): Promise<PluginResult> => {
-  initPermissions(client, directory)
-  initManager(client)
-
-  return {
-    tool: {
-      pty_spawn: ptySpawn,
-      pty_write: ptyWrite,
-      pty_read: ptyRead,
-      pty_list: ptyList,
-      pty_kill: ptyKill,
-    },
-    event: async ({ event }) => {
-      if (event.type === 'session.deleted') {
-        manager.cleanupBySession(event.properties.info.id)
-      }
-    },
-  }
-}

package/src/internals/plugins/pty/pty/buffer.ts

@@ -1,75 +0,0 @@
-// Default buffer size in characters (approximately 1MB)
-const DEFAULT_MAX_BUFFER_SIZE = parseInt(process.env.PTY_MAX_BUFFER_SIZE || '1000000', 10)
-
-export interface SearchMatch {
-  lineNumber: number
-  text: string
-}
-
-export class RingBuffer {
-  private buffer: string = ''
-  private maxSize: number
-
-  constructor(maxSize: number = DEFAULT_MAX_BUFFER_SIZE) {
-    this.maxSize = maxSize
-  }
-
-  append(data: string): void {
-    this.buffer += data
-    if (this.buffer.length > this.maxSize) {
-      this.buffer = this.buffer.slice(-this.maxSize)
-    }
-  }
-
-  private splitBufferLines(): string[] {
-    const lines: string[] = this.buffer.split('\n')
-    // Remove empty string at end if buffer doesn't end with newline
-    if (lines.length && lines[lines.length - 1] === '') {
-      lines.pop()
-    }
-    return lines
-  }
-
-  read(offset: number = 0, limit?: number): string[] {
-    if (this.buffer === '') return []
-    const lines: string[] = this.splitBufferLines()
-    const start = Math.max(0, offset)
-    const end = limit !== undefined ? start + limit : lines.length
-    return lines.slice(start, end)
-  }
-
-  readRaw(): string {
-    return this.buffer
-  }
-
-  search(pattern: RegExp): SearchMatch[] {
-    const matches: SearchMatch[] = []
-    const lines: string[] = this.splitBufferLines()
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i]
-      if (line && pattern.test(line)) {
-        matches.push({ lineNumber: i + 1, text: line })
-      }
-    }
-    return matches
-  }
-
-  get length(): number {
-    if (this.buffer === '') return 0
-    const lines = this.splitBufferLines()
-    return lines.length
-  }
-
-  get byteLength(): number {
-    return this.buffer.length
-  }
-
-  flush(): void {
-    // No-op in new implementation
-  }
-
-  clear(): void {
-    this.buffer = ''
-  }
-}

package/src/internals/plugins/pty/pty/formatters.ts

@@ -1,22 +0,0 @@
-import type { PTYSessionInfo } from './types'
-
-export function formatSessionInfo(session: PTYSessionInfo): string[] {
-  const exitInfo = session.exitCode !== undefined ? ` | exit: ${session.exitCode}` : ''
-  const exitSignal = session.exitSignal ? ` | signal: ${session.exitSignal}` : ''
-  return [
-    `[${session.id}] ${session.title}`,
-    `  Command: ${session.command} ${session.args.join(' ')}`,
-    `  Status: ${session.status}${exitInfo}${exitSignal}`,
-    `  PID: ${session.pid}`,
-    `  Lines: ${session.lineCount}`,
-    `  Workdir: ${session.workdir}`,
-    `  Created: ${session.createdAt}`,
-    '',
-  ]
-}
-
-export function formatLine(line: string, lineNum: number, maxLength: number = 2000): string {
-  const lineNumStr = lineNum.toString().padStart(5, '0')
-  const truncatedLine = line.length > maxLength ? `${line.slice(0, maxLength)}...` : line
-  return `${lineNumStr}| ${truncatedLine}`
-}

package/src/internals/plugins/pty/pty/manager.ts

@@ -1,175 +0,0 @@
-import type { OpencodeClient } from '@opencode-ai/sdk'
-import { semver } from 'bun'
-import { Terminal } from 'bun-pty'
-import { version as bunPtyVersion } from 'bun-pty/package.json'
-import { NotificationManager } from './notification-manager'
-import { OutputManager } from './output-manager'
-import { SessionLifecycleManager } from './session-lifecycle'
-import type { PTYSessionInfo, ReadResult, SearchResult, SpawnOptions } from './types'
-import { withSession } from './utils'
-
-// Monkey-patch bun-pty to fix race condition in _startReadLoop
-// Temporary workaround until https://github.com/sursaone/bun-pty/pull/37 is merged
-if (semver.order(bunPtyVersion, '0.4.8') > 0) {
-  throw new Error(
-    `bun-pty version ${bunPtyVersion} is too new for patching; remove the workaround.`
-  )
-}
-
-const proto = Terminal.prototype as unknown as { _startReadLoop?: (...args: unknown[]) => unknown }
-
-const original = proto._startReadLoop
-
-if (typeof original === 'function') {
-  proto._startReadLoop = async function (this: InstanceType<typeof Terminal>, ...args: unknown[]) {
-    await Promise.resolve() // Yield to allow event handlers to be registered
-    return original.apply(this, args)
-  }
-}
-
-type SessionUpdateCallback = (session: PTYSessionInfo) => void
-
-export const sessionUpdateCallbacks: SessionUpdateCallback[] = []
-
-export function registerSessionUpdateCallback(callback: SessionUpdateCallback) {
-  sessionUpdateCallbacks.push(callback)
-}
-
-export function removeSessionUpdateCallback(callback: SessionUpdateCallback) {
-  const index = sessionUpdateCallbacks.indexOf(callback)
-  if (index !== -1) {
-    sessionUpdateCallbacks.splice(index, 1)
-  }
-}
-
-function notifySessionUpdate(session: PTYSessionInfo) {
-  for (const callback of sessionUpdateCallbacks) {
-    try {
-      callback(session)
-    } catch {
-      // Ignore callback errors
-    }
-  }
-}
-
-type RawOutputCallback = (session: PTYSessionInfo, rawData: string) => void
-
-export const rawOutputCallbacks: RawOutputCallback[] = []
-
-export function registerRawOutputCallback(callback: RawOutputCallback): void {
-  rawOutputCallbacks.push(callback)
-}
-
-export function removeRawOutputCallback(callback: RawOutputCallback): void {
-  const index = rawOutputCallbacks.indexOf(callback)
-  if (index !== -1) {
-    rawOutputCallbacks.splice(index, 1)
-  }
-}
-
-function notifyRawOutput(session: PTYSessionInfo, rawData: string): void {
-  for (const callback of rawOutputCallbacks) {
-    try {
-      callback(session, rawData)
-    } catch {
-      // Ignore callback errors
-    }
-  }
-}
-
-class PTYManager {
-  private lifecycleManager = new SessionLifecycleManager()
-  private outputManager = new OutputManager()
-  private notificationManager = new NotificationManager()
-
-  init(client: OpencodeClient): void {
-    this.notificationManager.init(client)
-  }
-
-  clearAllSessions(): void {
-    this.lifecycleManager.clearAllSessions()
-  }
-
-  spawn(opts: SpawnOptions): PTYSessionInfo {
-    const session = this.lifecycleManager.spawn(
-      opts,
-      (session, data) => {
-        notifyRawOutput(this.lifecycleManager.toInfo(session), data)
-      },
-      async (session, exitCode) => {
-        notifySessionUpdate(this.lifecycleManager.toInfo(session))
-        if (session?.notifyOnExit) {
-          await this.notificationManager.sendExitNotification(session, exitCode || 0)
-        }
-      }
-    )
-    notifySessionUpdate(session)
-    return session
-  }
-
-  write(id: string, data: string): boolean {
-    return withSession(
-      this.lifecycleManager,
-      id,
-      (session) => this.outputManager.write(session, data),
-      false
-    )
-  }
-
-  read(id: string, offset: number = 0, limit?: number): ReadResult | null {
-    return withSession(
-      this.lifecycleManager,
-      id,
-      (session) => this.outputManager.read(session, offset, limit),
-      null
-    )
-  }
-
-  search(id: string, pattern: RegExp, offset: number = 0, limit?: number): SearchResult | null {
-    return withSession(
-      this.lifecycleManager,
-      id,
-      (session) => this.outputManager.search(session, pattern, offset, limit),
-      null
-    )
-  }
-
-  list(): PTYSessionInfo[] {
-    return this.lifecycleManager.listSessions().map((s) => this.lifecycleManager.toInfo(s))
-  }
-
-  get(id: string): PTYSessionInfo | null {
-    return withSession(
-      this.lifecycleManager,
-      id,
-      (session) => this.lifecycleManager.toInfo(session),
-      null
-    )
-  }
-
-  getRawBuffer(id: string): { raw: string; byteLength: number } | null {
-    return withSession(
-      this.lifecycleManager,
-      id,
-      (session) => ({
-        raw: session.buffer.readRaw(),
-        byteLength: session.buffer.byteLength,
-      }),
-      null
-    )
-  }
-
-  kill(id: string, cleanup: boolean = false): boolean {
-    return this.lifecycleManager.kill(id, cleanup)
-  }
-
-  cleanupBySession(parentSessionId: string): void {
-    this.lifecycleManager.cleanupBySession(parentSessionId)
-  }
-}
-
-export const manager = new PTYManager()
-
-export function initManager(opcClient: OpencodeClient): void {
-  manager.init(opcClient)
-}

package/src/internals/plugins/pty/pty/notification-manager.ts

@@ -1,75 +0,0 @@
-import type { PTYSession } from './types'
-import type { OpencodeClient } from '@opencode-ai/sdk'
-import { NOTIFICATION_LINE_TRUNCATE, NOTIFICATION_TITLE_TRUNCATE } from '../constants'
-
-export class NotificationManager {
-  private client: OpencodeClient | null = null
-
-  init(client: OpencodeClient): void {
-    this.client = client
-  }
-
-  async sendExitNotification(session: PTYSession, exitCode: number): Promise<void> {
-    if (!this.client) {
-      return
-    }
-
-    try {
-      const message = this.buildExitNotification(session, exitCode)
-      await this.client.session.promptAsync({
-        path: { id: session.parentSessionId },
-        body: {
-          parts: [{ type: 'text', text: message }],
-          ...(session.parentAgent ? { agent: session.parentAgent } : {}),
-        },
-      })
-    } catch {
-      // Ignore notification errors
-    }
-  }
-
-  private buildExitNotification(session: PTYSession, exitCode: number): string {
-    const lineCount = session.buffer.length
-    let lastLine = ''
-    if (lineCount > 0) {
-      for (let i = lineCount - 1; i >= 0; i--) {
-        const bufferLines = session.buffer.read(i, 1)
-        const line = bufferLines[0]
-        if (line !== undefined && line.trim() !== '') {
-          lastLine =
-            line.length > NOTIFICATION_LINE_TRUNCATE
-              ? `${line.slice(0, NOTIFICATION_LINE_TRUNCATE)}...`
-              : line
-          break
-        }
-      }
-    }
-
-    const displayTitle = session.description ?? session.title
-    const truncatedTitle =
-      displayTitle.length > NOTIFICATION_TITLE_TRUNCATE
-        ? `${displayTitle.slice(0, NOTIFICATION_TITLE_TRUNCATE)}...`
-        : displayTitle
-
-    const lines = [
-      '<pty_exited>',
-      `ID: ${session.id}`,
-      `Description: ${truncatedTitle}`,
-      `Exit Code: ${exitCode}`,
-      `Output Lines: ${lineCount}`,
-      `Last Line: ${lastLine}`,
-      '</pty_exited>',
-      '',
-    ]
-
-    if (exitCode === 0) {
-      lines.push('Use pty_read to check the full output.')
-    } else {
-      lines.push(
-        'Process failed. Use pty_read with the pattern parameter to search for errors in the output.'
-      )
-    }
-
-    return lines.join('\n')
-  }
-}

package/src/internals/plugins/pty/pty/output-manager.ts

@@ -1,29 +0,0 @@
-import type { PTYSession, ReadResult, SearchResult } from './types'
-
-export class OutputManager {
-  write(session: PTYSession, data: string): boolean {
-    try {
-      session.process?.write(data)
-      return true
-    } catch {
-      return true // allow write to exited process for tests
-    }
-  }
-
-  read(session: PTYSession, offset: number = 0, limit?: number): ReadResult {
-    const lines = session.buffer.read(offset, limit)
-    const totalLines = session.buffer.length
-    const hasMore = offset + lines.length < totalLines
-    return { lines, totalLines, offset, hasMore }
-  }
-
-  search(session: PTYSession, pattern: RegExp, offset: number = 0, limit?: number): SearchResult {
-    const allMatches = session.buffer.search(pattern)
-    const totalMatches = allMatches.length
-    const totalLines = session.buffer.length
-    const paginatedMatches =
-      limit !== undefined ? allMatches.slice(offset, offset + limit) : allMatches.slice(offset)
-    const hasMore = offset + paginatedMatches.length < totalMatches
-    return { matches: paginatedMatches, totalMatches, totalLines, offset, hasMore }
-  }
-}

package/src/internals/plugins/pty/pty/permissions.ts

@@ -1,115 +0,0 @@
-import type { PluginClient } from '../types'
-import { allStructured } from './wildcard'
-
-type PermissionAction = 'allow' | 'ask' | 'deny'
-type BashPermissions = PermissionAction | Record<string, PermissionAction>
-
-interface PermissionConfig {
-  bash?: BashPermissions
-  external_directory?: PermissionAction
-}
-
-let _client: PluginClient | null = null
-let _directory: string | null = null
-
-export function initPermissions(client: PluginClient, directory: string): void {
-  _client = client
-  _directory = directory
-}
-
-async function getPermissionConfig(): Promise<PermissionConfig> {
-  if (!_client) {
-    return {}
-  }
-  try {
-    const response = await _client.config.get()
-    if (response.error || !response.data) {
-      return {}
-    }
-    return (response.data as { permission?: PermissionConfig }).permission ?? {}
-  } catch {
-    return {}
-  }
-}
-
-async function showToast(
-  message: string,
-  variant: 'info' | 'success' | 'error' = 'info'
-): Promise<void> {
-  if (!_client) return
-  try {
-    await _client.tui.showToast({ body: { message, variant } })
-  } catch {
-    // Ignore toast errors
-  }
-}
-
-async function denyWithToast(msg: string, details?: string): Promise<never> {
-  await showToast(msg, 'error')
-  throw new Error(details ? `${msg} ${details}` : msg)
-}
-
-async function handleAskPermission(commandLine: string): Promise<never> {
-  await denyWithToast(
-    `PTY: Command "${commandLine}" requires permission (treated as denied)`,
-    `PTY spawn denied: Command "${commandLine}" requires user permission which is not supported by this plugin. Configure explicit "allow" or "deny" in your opencode.json permission.bash settings.`
-  )
-  throw new Error('Unreachable') // For TS, should never hit.
-}
-
-export async function checkCommandPermission(command: string, args: string[]): Promise<void> {
-  const config = await getPermissionConfig()
-  const bashPerms = config.bash
-
-  if (!bashPerms) {
-    return
-  }
-
-  if (typeof bashPerms === 'string') {
-    if (bashPerms === 'deny') {
-      await denyWithToast('PTY spawn denied: All bash commands are disabled by user configuration.')
-    }
-    if (bashPerms === 'ask') {
-      await handleAskPermission(command)
-    }
-    return
-  }
-
-  const action = allStructured({ head: command, tail: args }, bashPerms)
-
-  if (action === 'deny') {
-    await denyWithToast(
-      `PTY spawn denied: Command "${command} ${args.join(' ')}" is explicitly denied by user configuration.`
-    )
-  }
-
-  if (action === 'ask') {
-    await handleAskPermission(`${command} ${args.join(' ')}`)
-  }
-}
-
-export async function checkWorkdirPermission(workdir: string): Promise<void> {
-  if (!_directory) {
-    return
-  }
-
-  const normalizedWorkdir = workdir.replace(/\/$/, '')
-  const normalizedProject = _directory.replace(/\/$/, '')
-
-  if (normalizedWorkdir.startsWith(normalizedProject)) {
-    return
-  }
-
-  const config = await getPermissionConfig()
-  const extDirPerm = config.external_directory
-
-  if (extDirPerm === 'deny') {
-    await denyWithToast(
-      `PTY spawn denied: Working directory "${workdir}" is outside project directory "${_directory}". External directory access is denied by user configuration.`
-    )
-  }
-
-  if (extDirPerm === 'ask') {
-    // TODO: Implement user prompt for external directory access
-  }
-}

package/src/internals/plugins/pty/pty/session-lifecycle.ts

@@ -1,161 +0,0 @@
-import { spawn, type IPty } from 'bun-pty'
-import { RingBuffer } from './buffer'
-import type { PTYSession, PTYSessionInfo, SpawnOptions } from './types'
-import { DEFAULT_TERMINAL_COLS, DEFAULT_TERMINAL_ROWS } from '../constants'
-
-const SESSION_ID_BYTE_LENGTH = 4
-
-function generateId(): string {
-  const hex = Array.from(crypto.getRandomValues(new Uint8Array(SESSION_ID_BYTE_LENGTH)))
-    .map((b) => b.toString(16).padStart(2, '0'))
-    .join('')
-  return `pty_${hex}`
-}
-
-export class SessionLifecycleManager {
-  private sessions: Map<string, PTYSession> = new Map()
-
-  private createSessionObject(opts: SpawnOptions): PTYSession {
-    const id = generateId()
-    const args = opts.args ?? []
-    const workdir = opts.workdir ?? process.cwd()
-    const title =
-      opts.title ?? (`${opts.command} ${args.join(' ')}`.trim() || `Terminal ${id.slice(-4)}`)
-
-    const buffer = new RingBuffer()
-    return {
-      id,
-      title,
-      description: opts.description,
-      command: opts.command,
-      args,
-      workdir,
-      env: opts.env,
-      status: 'running',
-      pid: 0, // will be set after spawn
-      createdAt: new Date(),
-      parentSessionId: opts.parentSessionId,
-      parentAgent: opts.parentAgent,
-      notifyOnExit: opts.notifyOnExit ?? false,
-      buffer,
-      process: null, // will be set
-    }
-  }
-
-  private spawnProcess(session: PTYSession): void {
-    const env = { ...process.env, ...session.env } as Record<string, string>
-    const ptyProcess: IPty = spawn(session.command, session.args, {
-      name: 'xterm-256color',
-      cols: DEFAULT_TERMINAL_COLS,
-      rows: DEFAULT_TERMINAL_ROWS,
-      cwd: session.workdir,
-      env,
-    })
-    session.process = ptyProcess
-    session.pid = ptyProcess.pid
-  }
-
-  private setupEventHandlers(
-    session: PTYSession,
-    onData: (session: PTYSession, data: string) => void,
-    onExit: (session: PTYSession, exitCode: number | null) => void
-  ): void {
-    session.process?.onData((data: string) => {
-      session.buffer.append(data)
-      onData(session, data)
-    })
-
-    session.process?.onExit(({ exitCode, signal }) => {
-      // Flush any remaining incomplete line in the buffer
-      session.buffer.flush()
-
-      if (session.status === 'killing') {
-        session.status = 'killed'
-      } else {
-        session.status = 'exited'
-      }
-      session.exitCode = exitCode
-      session.exitSignal = signal
-      onExit(session, exitCode)
-    })
-  }
-
-  spawn(
-    opts: SpawnOptions,
-    onData: (session: PTYSession, data: string) => void,
-    onExit: (session: PTYSession, exitCode: number | null) => void
-  ): PTYSessionInfo {
-    const session = this.createSessionObject(opts)
-    this.spawnProcess(session)
-    this.setupEventHandlers(session, onData, onExit)
-    this.sessions.set(session.id, session)
-    return this.toInfo(session)
-  }
-
-  kill(id: string, cleanup: boolean = false): boolean {
-    const session = this.sessions.get(id)
-    if (!session) {
-      return false
-    }
-
-    if (session.status === 'running') {
-      session.status = 'killing'
-      try {
-        session.process?.kill()
-      } catch {
-        // Ignore kill errors
-      }
-    }
-
-    if (cleanup) {
-      session.buffer.clear()
-      this.sessions.delete(id)
-    }
-
-    return true
-  }
-
-  private clearAllSessionsInternal(): void {
-    for (const id of [...this.sessions.keys()]) {
-      this.kill(id, true)
-    }
-  }
-
-  clearAllSessions(): void {
-    this.clearAllSessionsInternal()
-  }
-
-  cleanupBySession(parentSessionId: string): void {
-    for (const [id, session] of this.sessions) {
-      if (session.parentSessionId === parentSessionId) {
-        this.kill(id, true)
-      }
-    }
-  }
-
-  getSession(id: string): PTYSession | null {
-    return this.sessions.get(id) || null
-  }
-
-  listSessions(): PTYSession[] {
-    return Array.from(this.sessions.values())
-  }
-
-  toInfo(session: PTYSession): PTYSessionInfo {
-    return {
-      id: session.id,
-      title: session.title,
-      description: session.description,
-      command: session.command,
-      args: session.args,
-      workdir: session.workdir,
-      status: session.status,
-      notifyOnExit: session.notifyOnExit,
-      exitCode: session.exitCode,
-      exitSignal: session.exitSignal,
-      pid: session.pid,
-      createdAt: session.createdAt.toISOString(),
-      lineCount: session.buffer.length,
-    }
-  }
-}