@hiai-gg/hiai-opencode 0.1.0 → 0.1.1

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

@@ -1,71 +1,71 @@
-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
-  },
-})
+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 +1,47 @@
-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
+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 +1,96 @@
-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}"`
-  },
-})
+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 +1,28 @@
-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"
+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"

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

@@ -1,67 +1,67 @@
-import type { IPty } from 'bun-pty'
-import type { RingBuffer } from './buffer'
-
-export type PTYStatus = 'running' | 'exited' | 'killing' | 'killed'
-
-export interface PTYSession {
-  id: string
-  title: string
-  description?: string
-  command: string
-  args: string[]
-  workdir: string
-  env?: Record<string, string>
-  status: PTYStatus
-  exitCode?: number
-  exitSignal?: number | string
-  pid: number
-  createdAt: Date
-  parentSessionId: string
-  parentAgent?: string
-  notifyOnExit: boolean
-  buffer: RingBuffer
-  process: IPty | null
-}
-
-export interface PTYSessionInfo {
-  id: string
-  title: string
-  description?: string
-  command: string
-  args: string[]
-  workdir: string
-  status: PTYStatus
-  notifyOnExit: boolean
-  exitCode?: number
-  exitSignal?: number | string
-  pid: number
-  createdAt: string
-  lineCount: number
-}
-
-export interface SpawnOptions {
-  command: string
-  args?: string[]
-  workdir?: string
-  env?: Record<string, string>
-  title?: string
-  description?: string
-  parentSessionId: string
-  parentAgent?: string
-  notifyOnExit?: boolean
-}
-
-export interface ReadResult {
-  lines: string[]
-  totalLines: number
-  offset: number
-  hasMore: boolean
-}
-
-export interface SearchResult {
-  matches: Array<{ lineNumber: number; text: string }>
-  totalMatches: number
-  totalLines: number
-  offset: number
-  hasMore: boolean
-}
+import type { IPty } from 'bun-pty'
+import type { RingBuffer } from './buffer'
+
+export type PTYStatus = 'running' | 'exited' | 'killing' | 'killed'
+
+export interface PTYSession {
+  id: string
+  title: string
+  description?: string
+  command: string
+  args: string[]
+  workdir: string
+  env?: Record<string, string>
+  status: PTYStatus
+  exitCode?: number
+  exitSignal?: number | string
+  pid: number
+  createdAt: Date
+  parentSessionId: string
+  parentAgent?: string
+  notifyOnExit: boolean
+  buffer: RingBuffer
+  process: IPty | null
+}
+
+export interface PTYSessionInfo {
+  id: string
+  title: string
+  description?: string
+  command: string
+  args: string[]
+  workdir: string
+  status: PTYStatus
+  notifyOnExit: boolean
+  exitCode?: number
+  exitSignal?: number | string
+  pid: number
+  createdAt: string
+  lineCount: number
+}
+
+export interface SpawnOptions {
+  command: string
+  args?: string[]
+  workdir?: string
+  env?: Record<string, string>
+  title?: string
+  description?: string
+  parentSessionId: string
+  parentAgent?: string
+  notifyOnExit?: boolean
+}
+
+export interface ReadResult {
+  lines: string[]
+  totalLines: number
+  offset: number
+  hasMore: boolean
+}
+
+export interface SearchResult {
+  matches: Array<{ lineNumber: number; text: string }>
+  totalMatches: number
+  totalLines: number
+  offset: number
+  hasMore: boolean
+}

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

@@ -1,21 +1,21 @@
-export function buildSessionNotFoundError(id: string): Error {
-  return new Error(`PTY session '${id}' not found. Use pty_list to see active sessions.`)
-}
-
-/**
- * Helper to DRY up session-get/null-check logic
- * - manager: object with a getSession(id) or similar method
- * - id: session id
- * - fn: function called with session if found
- * - defaultValue: what to return if not found (default null)
- */
-export function withSession<TSession, TResult>(
-  manager: { getSession(id: string): TSession | null },
-  id: string,
-  fn: (session: TSession) => TResult,
-  defaultValue: TResult
-): TResult {
-  const session = manager.getSession(id)
-  if (!session) return defaultValue
-  return fn(session)
-}
+export function buildSessionNotFoundError(id: string): Error {
+  return new Error(`PTY session '${id}' not found. Use pty_list to see active sessions.`)
+}
+
+/**
+ * Helper to DRY up session-get/null-check logic
+ * - manager: object with a getSession(id) or similar method
+ * - id: session id
+ * - fn: function called with session if found
+ * - defaultValue: what to return if not found (default null)
+ */
+export function withSession<TSession, TResult>(
+  manager: { getSession(id: string): TSession | null },
+  id: string,
+  fn: (session: TSession) => TResult,
+  defaultValue: TResult
+): TResult {
+  const session = manager.getSession(id)
+  if (!session) return defaultValue
+  return fn(session)
+}