@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/internals/plugins/pty/pty/tools/kill.ts

@@ -1,41 +0,0 @@
-import { tool, type ToolDefinition } from '@opencode-ai/plugin'
-import { manager } from '../manager'
-import { buildSessionNotFoundError } from '../utils'
-import DESCRIPTION from './kill.txt'
-
-export const ptyKill: ToolDefinition = tool({
-  description: DESCRIPTION,
-  args: {
-    id: tool.schema.string().describe('The PTY session ID (e.g., pty_a1b2c3d4)'),
-    cleanup: tool.schema
-      .boolean()
-      .optional()
-      .describe('If true, removes the session and frees the buffer (default: false)'),
-  },
-  async execute(args) {
-    const session = manager.get(args.id)
-    if (!session) {
-      throw buildSessionNotFoundError(args.id)
-    }
-
-    const wasRunning = session.status === 'running'
-    const cleanup = args.cleanup ?? false
-    const success = manager.kill(args.id, cleanup)
-
-    if (!success) {
-      throw new Error(`Failed to kill PTY session '${args.id}'.`)
-    }
-
-    const action = wasRunning ? 'Killed' : 'Cleaned up'
-    const cleanupNote = cleanup ? ' (session removed)' : ' (session retained for log access)'
-
-    return [
-      `<pty_killed>`,
-      `${action}: ${args.id}${cleanupNote}`,
-      `Title: ${session.title}`,
-      `Command: ${session.command} ${session.args.join(' ')}`,
-      `Final line count: ${session.lineCount}`,
-      `</pty_killed>`,
-    ].join('\n')
-  },
-})

package/src/internals/plugins/pty/pty/tools/kill.txt

@@ -1,25 +0,0 @@
-Terminates a PTY session and optionally cleans up its buffer.
-
-Use this tool to:
-- Stop a running process (sends SIGTERM)
-- Clean up an exited session to free memory
-- Remove a session from the list
-
-Usage:
-- `id`: The PTY session ID (from pty_spawn or pty_list)
-- `cleanup`: If true, removes the session and frees the buffer (default: false)
-
-Behavior:
-- If the session is running, it will be killed (status becomes "killed")
-- If cleanup=false (default), the session remains in the list with its output buffer intact
-- If cleanup=true, the session is removed entirely and the buffer is freed
-- Keeping sessions without cleanup allows you to compare logs between runs
-
-Tips:
-- Use cleanup=false if you might want to read the output later
-- Use cleanup=true when you're done with the session entirely
-- To send Ctrl+C instead of killing, use pty_write with data="\x03"
-
-Examples:
-- Kill but keep logs: cleanup=false (or omit)
-- Kill and remove: cleanup=true

package/src/internals/plugins/pty/pty/tools/list.ts

@@ -1,25 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { manager } from '../manager'
-import { formatSessionInfo } from '../formatters'
-import DESCRIPTION from './list.txt'
-
-export const ptyList = tool({
-  description: DESCRIPTION,
-  args: {},
-  async execute() {
-    const sessions = manager.list()
-
-    if (sessions.length === 0) {
-      return '<pty_list>\nNo active PTY sessions.\n</pty_list>'
-    }
-
-    const lines = ['<pty_list>']
-    for (const session of sessions) {
-      lines.push(...formatSessionInfo(session))
-    }
-    lines.push(`Total: ${sessions.length} session(s)`)
-    lines.push('</pty_list>')
-
-    return lines.join('\n')
-  },
-})

package/src/internals/plugins/pty/pty/tools/list.txt

@@ -1,22 +0,0 @@
-Lists all PTY sessions (active and exited).
-
-Use this tool to:
-- See all running and exited PTY sessions
-- Get session IDs for use with other pty_* tools
-- Check the status and output line count of each session
-- Monitor which processes are still running
-
-Returns for each session:
-- `id`: Unique identifier for use with other tools
-- `title`: Human-readable name
-- `command`: The command that was executed
-- `status`: Current status (running, exited, killed)
-- `exitCode`: Exit code (if exited/killed)
-- `pid`: Process ID
-- `lineCount`: Number of lines in the output buffer
-- `createdAt`: When the session was created
-
-Tips:
-- Use the session ID with pty_read, pty_write, or pty_kill
-- Sessions remain in the list after exit until explicitly cleaned up with pty_kill
-- This allows you to compare output from multiple sessions

package/src/internals/plugins/pty/pty/tools/read.ts

@@ -1,234 +0,0 @@
-import { tool, type ToolDefinition } from '@opencode-ai/plugin'
-import { manager } from '../manager'
-import { DEFAULT_READ_LIMIT, MAX_LINE_LENGTH } from '../../shared/constants'
-import { buildSessionNotFoundError } from '../utils'
-import { formatLine } from '../formatters'
-import type { PTYSessionInfo } from '../types'
-import DESCRIPTION from './read.txt'
-
-const NOTIFY_ON_EXIT_REMINDER = [
-  `<system_reminder>`,
-  `This session was started with \`notifyOnExit=true\`.`,
-  `Completion signal is the future \`<pty_exited>\` message, not repeated \`pty_read\` calls.`,
-  `If you only need to know whether the command finished, stop polling and wait for \`<pty_exited>\`.`,
-  `Do not use sleep plus \`pty_read\` loops to check completion.`,
-  `Use \`pty_read\` only when you need live output now, the user explicitly asks for logs, or the exit notification reports a non-zero status and you need to investigate.`,
-  `</system_reminder>`,
-].join('\n')
-
-interface ReadArgs {
-  id: string
-  offset?: number
-  limit?: number
-  pattern?: string
-  ignoreCase?: boolean
-}
-
-/**
- * Formats PTY output with XML tags and pagination
- */
-function formatPtyOutput(
-  id: string,
-  status: string,
-  pattern: string | undefined,
-  formattedLines: string[],
-  hasMore: boolean,
-  paginationMessage: string,
-  endMessage: string
-): string {
-  const output = [
-    `<pty_output id="${id}" status="${status}"${pattern ? ` pattern="${pattern}"` : ''}>`,
-    ...formattedLines,
-    '',
-    hasMore ? paginationMessage : endMessage,
-    `</pty_output>`,
-  ]
-  return output.join('\n')
-}
-
-function appendNotifyOnExitReminder(output: string, session: PTYSessionInfo): string {
-  if (!session.notifyOnExit || session.status !== 'running') {
-    return output
-  }
-
-  return `${output}\n\n${NOTIFY_ON_EXIT_REMINDER}`
-}
-
-/**
- * Validates and creates a RegExp from pattern string
- */
-function validateAndCreateRegex(pattern: string, ignoreCase?: boolean): RegExp {
-  if (!validateRegex(pattern)) {
-    throw new Error(
-      `Potentially dangerous regex pattern rejected: '${pattern}'. Please use a safer pattern.`
-    )
-  }
-
-  try {
-    return new RegExp(pattern, ignoreCase ? 'i' : '')
-  } catch (e) {
-    const error = e instanceof Error ? e.message : String(e)
-    throw new Error(`Invalid regex pattern '${pattern}': ${error}`)
-  }
-}
-
-/**
- * Handles pattern-based reading and formatting
- */
-function handlePatternRead(
-  id: string,
-  pattern: string,
-  ignoreCase: boolean | undefined,
-  session: PTYSessionInfo,
-  offset: number,
-  limit: number
-): string {
-  const regex = validateAndCreateRegex(pattern, ignoreCase)
-
-  const result = manager.search(id, regex, offset, limit)
-  if (!result) {
-    throw buildSessionNotFoundError(id)
-  }
-
-  if (result.matches.length === 0) {
-    return appendNotifyOnExitReminder(
-      [
-        `<pty_output id="${id}" status="${session.status}" pattern="${pattern}">`,
-        `No lines matched the pattern '${pattern}'.`,
-        `Total lines in buffer: ${result.totalLines}`,
-        `</pty_output>`,
-      ].join('\n'),
-      session
-    )
-  }
-
-  const formattedLines = result.matches.map((match) =>
-    formatLine(match.text, match.lineNumber, MAX_LINE_LENGTH)
-  )
-
-  const paginationMessage = `(${result.matches.length} of ${result.totalMatches} matches shown. Use offset=${offset + result.matches.length} to see more.)`
-  const endMessage = `(${result.totalMatches} match${result.totalMatches === 1 ? '' : 'es'} from ${result.totalLines} total lines)`
-
-  return appendNotifyOnExitReminder(
-    formatPtyOutput(
-      id,
-      session.status,
-      pattern,
-      formattedLines,
-      result.hasMore,
-      paginationMessage,
-      endMessage
-    ),
-    session
-  )
-}
-
-/**
- * Handles plain reading and formatting
- */
-function handlePlainRead(
-  args: ReadArgs,
-  session: PTYSessionInfo,
-  offset: number,
-  limit: number
-): string {
-  const result = manager.read(args.id, offset, limit)
-  if (!result) {
-    throw buildSessionNotFoundError(args.id)
-  }
-
-  if (result.lines.length === 0) {
-    return appendNotifyOnExitReminder(
-      [
-        `<pty_output id="${args.id}" status="${session.status}">`,
-        `(No output available - buffer is empty)`,
-        `Total lines: ${result.totalLines}`,
-        `</pty_output>`,
-      ].join('\n'),
-      session
-    )
-  }
-
-  const formattedLines = result.lines.map((line, index) =>
-    formatLine(line, result.offset + index + 1, MAX_LINE_LENGTH)
-  )
-
-  const paginationMessage = `(Buffer has more lines. Use offset=${result.offset + result.lines.length} to read beyond line ${result.offset + result.lines.length})`
-  const endMessage = `(End of buffer - total ${result.totalLines} lines)`
-
-  return appendNotifyOnExitReminder(
-    formatPtyOutput(
-      args.id,
-      session.status,
-      undefined,
-      formattedLines,
-      result.hasMore,
-      paginationMessage,
-      endMessage
-    ),
-    session
-  )
-}
-
-/**
- * Formats a single line with line number and truncation
- */
-function validateRegex(pattern: string): boolean {
-  try {
-    new RegExp(pattern)
-    // Check for potentially dangerous patterns that can cause exponential backtracking
-    // This is a basic check - more sophisticated validation could be added
-    const dangerousPatterns = [
-      /\(\?:.*\)\*.*\(\?:.*\)\*/, // nested optional groups with repetition
-      /.*\(\.\*\?\)\{2,\}.*/, // overlapping non-greedy quantifiers
-      /.*\(.*\|.*\)\{3,\}.*/, // complex alternation with repetition
-    ]
-    return !dangerousPatterns.some((dangerous) => dangerous.test(pattern))
-  } catch {
-    return false
-  }
-}
-
-export const ptyRead: ToolDefinition = tool({
-  description: DESCRIPTION,
-  args: {
-    id: tool.schema.string().describe('The PTY session ID (e.g., pty_a1b2c3d4)'),
-    offset: tool.schema
-      .number()
-      .optional()
-      .describe(
-        'Line number to start reading from (0-based, defaults to 0). When using pattern, this applies to filtered matches.'
-      ),
-    limit: tool.schema
-      .number()
-      .optional()
-      .describe(
-        'Number of lines to read (defaults to 500). When using pattern, this applies to filtered matches.'
-      ),
-    pattern: tool.schema
-      .string()
-      .optional()
-      .describe(
-        'Regex pattern to filter lines. When set, only matching lines are returned, then offset/limit apply to the matches.'
-      ),
-    ignoreCase: tool.schema
-      .boolean()
-      .optional()
-      .describe('Case-insensitive pattern matching (default: false)'),
-  },
-  async execute(args) {
-    const session = manager.get(args.id)
-    if (!session) {
-      throw buildSessionNotFoundError(args.id)
-    }
-
-    const offset = args.offset ?? 0
-    const limit = args.limit ?? DEFAULT_READ_LIMIT
-
-    if (args.pattern) {
-      return handlePatternRead(args.id, args.pattern, args.ignoreCase, session, offset, limit)
-    } else {
-      return handlePlainRead(args, session, offset, limit)
-    }
-  },
-})

package/src/internals/plugins/pty/pty/tools/read.txt

@@ -1,39 +0,0 @@
-Reads output from a PTY session's buffer.
-
-The PTY maintains a rolling buffer of output lines. Use offset and limit to paginate through the output, similar to reading a file.
-
-Usage:
-- `id`: The PTY session ID (from pty_spawn or pty_list)
-- `offset`: Line number to start reading from (0-based, defaults to 0)
-- `limit`: Number of lines to read (defaults to 500)
-- `pattern`: Regex pattern to filter lines (optional)
-- `ignoreCase`: Case-insensitive pattern matching (default: false)
-
-Returns:
-- Numbered lines of output (similar to cat -n format)
-- Total line count in the buffer
-- Indicator if more lines are available
-
-The buffer stores up to PTY_MAX_BUFFER_LINES (default: 50000) lines. Older lines are discarded when the limit is reached.
-
-Pattern Filtering:
-- When `pattern` is set, lines are FILTERED FIRST using the regex, then offset/limit apply to the MATCHES
-- Original line numbers are preserved so you can see where matches occurred in the buffer
-- Supports full regex syntax (e.g., "error", "ERROR|WARN", "failed.*connection", etc.)
-- If the pattern is invalid, an error message is returned explaining the issue
-- If no lines match the pattern, a clear message indicates zero matches
-
-Tips:
-- To see the latest output, use a high offset or omit offset to read from the start
-- To tail recent output, calculate offset as (totalLines - N) where N is how many recent lines you want
-- Lines longer than 2000 characters are truncated
-- Empty output may mean the process hasn't produced output yet
-- If the session was started with `notifyOnExit=true`, do not use repeated `pty_read` calls only to detect completion; wait for the future `<pty_exited>` message instead
-
-Examples:
-- Read first 100 lines: offset=0, limit=100
-- Read lines 500-600: offset=500, limit=100
-- Read all available: omit both parameters
-- Find errors: pattern="error", ignoreCase=true
-- Find specific log levels: pattern="ERROR|WARN|FATAL"
-- First 10 matches only: pattern="error", limit=10

package/src/internals/plugins/pty/pty/tools/spawn.ts

@@ -1,71 +0,0 @@
-import { tool, type ToolDefinition } from '@opencode-ai/plugin'
-import { manager } from '../manager'
-import { checkCommandPermission, checkWorkdirPermission } from '../permissions'
-import DESCRIPTION from './spawn.txt'
-
-const NOTIFY_ON_EXIT_INSTRUCTIONS = [
-  `<system_reminder>`,
-  `Completion signal for this session is the future \`<pty_exited>\` message.`,
-  `If you only need to know whether the command finished, do not call \`pty_read\`; wait for \`<pty_exited>\`.`,
-  `Never use sleep plus \`pty_read\` loops to check completion for this session.`,
-  `Call \`pty_read\` before exit only if you need live output now, the user explicitly asks for logs, or the exit notification reports a non-zero status and you need to investigate.`,
-  `</system_reminder>`,
-].join('\n')
-
-export const ptySpawn: ToolDefinition = tool({
-  description: DESCRIPTION,
-  args: {
-    command: tool.schema.string().describe('The command/executable to run'),
-    args: tool.schema.array(tool.schema.string()).describe('Arguments to pass to the command'),
-    workdir: tool.schema.string().optional().describe('Working directory for the PTY session'),
-    env: tool.schema
-      .record(tool.schema.string(), tool.schema.string())
-      .optional()
-      .describe('Additional environment variables'),
-    title: tool.schema.string().optional().describe('Human-readable title for the session'),
-    description: tool.schema
-      .string()
-      .describe('Clear, concise description of what this PTY session is for in 5-10 words'),
-    notifyOnExit: tool.schema
-      .boolean()
-      .optional()
-      .describe(
-        'If true, sends a notification to the session when the process exits (default: false)'
-      ),
-  },
-  async execute(args, ctx) {
-    await checkCommandPermission(args.command, args.args ?? [])
-
-    if (args.workdir) {
-      await checkWorkdirPermission(args.workdir)
-    }
-
-    const sessionId = ctx.sessionID
-    const info = manager.spawn({
-      command: args.command,
-      args: args.args,
-      workdir: args.workdir,
-      env: args.env,
-      title: args.title,
-      description: args.description,
-      parentSessionId: sessionId,
-      parentAgent: ctx.agent,
-      notifyOnExit: args.notifyOnExit,
-    })
-
-    const output = [
-      `<pty_spawned>`,
-      `ID: ${info.id}`,
-      `Title: ${info.title}`,
-      `Command: ${info.command} ${info.args.join(' ')}`,
-      `Workdir: ${info.workdir}`,
-      `PID: ${info.pid}`,
-      `Status: ${info.status}`,
-      `NotifyOnExit: ${info.notifyOnExit}`,
-      `</pty_spawned>`,
-      ...(info.notifyOnExit ? ['', NOTIFY_ON_EXIT_INSTRUCTIONS] : []),
-    ].join('\n')
-
-    return output
-  },
-})

package/src/internals/plugins/pty/pty/tools/spawn.txt

@@ -1,47 +0,0 @@
-Spawns a new interactive PTY (pseudo-terminal) session that runs in the background.
-
-Unlike the built-in bash tool which runs commands synchronously and waits for completion, PTY sessions persist and allow you to:
-- Run long-running processes (dev servers, watch modes, etc.)
-- Send interactive input (including Ctrl+C, arrow keys, etc.)
-- Read output at any time
-- Manage multiple concurrent terminal sessions
-
-Usage:
-- The `command` parameter is required (e.g., "npm", "python", "bash")
-- Use `args` to pass arguments to the command (e.g., ["run", "dev"])
-- Use `workdir` to set the working directory (defaults to project root)
-- Use `env` to set additional environment variables
-- Use `title` to give the session a human-readable name
-- The `description` parameter is required: a clear, concise 5-10 word description
-- Use `notifyOnExit` to receive a notification when the process exits (default: false)
-
-Returns the session info including:
-- `id`: Unique identifier (pty_XXXXXXXX) for use with other pty_* tools
-- `pid`: Process ID
-- `status`: Current status ("running")
-
-After spawning, use:
-- `pty_write` to send input to the PTY
-- `pty_read` to read output from the PTY
-- `pty_list` to see all active PTY sessions
-- `pty_kill` to terminate the PTY
-
-Exit Notifications:
-When `notifyOnExit` is true, you will receive a message when the process exits containing:
-- Session ID and title
-- Exit code
-- Total output lines
-- Last line of output (truncated to 250 chars)
-
-This is useful for long-running processes where you want to be notified when they complete
-instead of polling with `pty_read`.
-- Completion signal is the future `<pty_exited>` message
-- If you only need to know whether the command finished, do not call `pty_read`; wait for `<pty_exited>`
-- Never use sleep plus `pty_read` loops to check completion
-- Use `pty_read` before exit only if you need live output now, the user explicitly asks for logs, or the exit notification reports a non-zero status and you need to investigate
-
-Examples:
-- Start a dev server: command="npm", args=["run", "dev"], title="Dev Server"
-- Start a Python REPL: command="python3", title="Python REPL"
-- Run tests in watch mode: command="npm", args=["test", "--", "--watch"]
-- Run build with notification: command="npm", args=["run", "build"], notifyOnExit=true

package/src/internals/plugins/pty/pty/tools/write.ts

@@ -1,96 +0,0 @@
-import { tool, type ToolDefinition } from '@opencode-ai/plugin'
-import { manager } from '../manager'
-import { checkCommandPermission } from '../permissions'
-import { buildSessionNotFoundError } from '../utils'
-import DESCRIPTION from './write.txt'
-
-const ETX = String.fromCharCode(3)
-const EOT = String.fromCharCode(4)
-
-/**
- * Parse escape sequences in a string to their actual byte values.
- * Handles: \n, \r, \t, \xNN (hex), \uNNNN (unicode), \\
- */
-function parseEscapeSequences(input: string): string {
-  return input.replace(/\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|[nrt\\])/g, (match, seq: string) => {
-    if (seq.startsWith('x')) {
-      return String.fromCharCode(parseInt(seq.slice(1), 16))
-    }
-    if (seq.startsWith('u')) {
-      return String.fromCharCode(parseInt(seq.slice(1), 16))
-    }
-    switch (seq) {
-      case 'n':
-        return '\n'
-      case 'r':
-        return '\r'
-      case 't':
-        return '\t'
-      case '\\':
-        return '\\'
-      default:
-        return match
-    }
-  })
-}
-
-function extractCommands(data: string): string[] {
-  const commands: string[] = []
-  const lines = data.split(/[\n\r]+/)
-  for (const line of lines) {
-    const trimmed = line.trim()
-    if (trimmed && !trimmed.startsWith(ETX) && !trimmed.startsWith(EOT)) {
-      commands.push(trimmed)
-    }
-  }
-  return commands
-}
-
-function parseCommand(commandLine: string): { command: string; args: string[] } {
-  const parts = commandLine.split(/\s+/).filter(Boolean)
-  const command = parts[0] ?? ''
-  const args = parts.slice(1)
-  return { command, args }
-}
-
-export const ptyWrite: ToolDefinition = tool({
-  description: DESCRIPTION,
-  args: {
-    id: tool.schema.string().describe('The PTY session ID (e.g., pty_a1b2c3d4)'),
-    data: tool.schema.string().describe('The input data to send to the PTY'),
-  },
-  async execute(args) {
-    const session = manager.get(args.id)
-    if (!session) {
-      throw buildSessionNotFoundError(args.id)
-    }
-
-    if (session.status !== 'running') {
-      throw new Error(`Cannot write to PTY '${args.id}' - session status is '${session.status}'.`)
-    }
-
-    // Parse escape sequences to actual bytes
-    const parsedData = parseEscapeSequences(args.data)
-
-    const commands = extractCommands(parsedData)
-    for (const commandLine of commands) {
-      const { command, args: cmdArgs } = parseCommand(commandLine)
-      if (command) {
-        await checkCommandPermission(command, cmdArgs)
-      }
-    }
-
-    const success = manager.write(args.id, parsedData)
-    if (!success) {
-      throw new Error(`Failed to write to PTY '${args.id}'.`)
-    }
-
-    const preview = args.data.length > 50 ? `${args.data.slice(0, 50)}...` : args.data
-    const displayPreview = preview
-      .replace(new RegExp(ETX, 'g'), '^C')
-      .replace(new RegExp(EOT, 'g'), '^D')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-    return `Sent ${args.data.length} bytes to ${args.id}: "${displayPreview}"`
-  },
-})

package/src/internals/plugins/pty/pty/tools/write.txt

@@ -1,28 +0,0 @@
-Sends input data to an active PTY session.
-
-Use this tool to:
-- Type commands or text into an interactive terminal
-- Send special key sequences (Ctrl+C, Enter, arrow keys, etc.)
-- Respond to prompts in interactive programs
-
-Usage:
-- `id`: The PTY session ID (from pty_spawn or pty_list)
-- `data`: The input to send (text, commands, or escape sequences)
-
-Common escape sequences:
-- Enter/newline: "\n" or "\r"
-- Ctrl+C (interrupt): "\x03"
-- Ctrl+D (EOF): "\x04"
-- Ctrl+Z (suspend): "\x1a"
-- Tab: "\t"
-- Arrow Up: "\x1b[A"
-- Arrow Down: "\x1b[B"
-- Arrow Right: "\x1b[C"
-- Arrow Left: "\x1b[D"
-
-Returns success or error message.
-
-Examples:
-- Send a command: data="ls -la\n"
-- Interrupt a process: data="\x03"
-- Answer a prompt: data="yes\n"