@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/shared/tmux/tmux-utils/session-spawn.ts

@@ -1,145 +0,0 @@
-import { spawn } from "bun"
-import type { TmuxConfig } from "../../../config/schema"
-import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"
-import type { SpawnPaneResult } from "../types"
-import { isInsideTmux } from "./environment"
-import { isServerRunning } from "./server-health"
-import { shellEscapeForDoubleQuotedCommand } from "../../shell-env"
-
-const ISOLATED_SESSION_NAME = "omo-agents"
-
-async function getWindowDimensions(
-	tmux: string,
-	sourcePaneId: string,
-): Promise<{ width: number; height: number } | null> {
-	const proc = spawn(
-		[tmux, "display", "-p", "-t", sourcePaneId, "#{window_width},#{window_height}"],
-		{ stdout: "pipe", stderr: "pipe" },
-	)
-	const exitCode = await proc.exited
-	const stdout = await new Response(proc.stdout).text()
-
-	if (exitCode !== 0) return null
-
-	const [width, height] = stdout.trim().split(",").map(Number)
-	if (Number.isNaN(width) || Number.isNaN(height)) return null
-
-	return { width, height }
-}
-
-async function sessionExists(tmux: string, sessionName: string): Promise<boolean> {
-	const proc = spawn([tmux, "has-session", "-t", sessionName], {
-		stdout: "ignore",
-		stderr: "ignore",
-	})
-	return (await proc.exited) === 0
-}
-
-export async function spawnTmuxSession(
-	sessionId: string,
-	description: string,
-	config: TmuxConfig,
-	serverUrl: string,
-	sourcePaneId?: string,
-): Promise<SpawnPaneResult> {
-	const { log } = await import("../../logger")
-
-	log("[spawnTmuxSession] called", {
-		sessionId,
-		description,
-		serverUrl,
-		configEnabled: config.enabled,
-	})
-
-	if (!config.enabled) {
-		log("[spawnTmuxSession] SKIP: config.enabled is false")
-		return { success: false }
-	}
-	if (!isInsideTmux()) {
-		log("[spawnTmuxSession] SKIP: not inside tmux", { TMUX: process.env.TMUX })
-		return { success: false }
-	}
-
-	const serverRunning = await isServerRunning(serverUrl)
-	if (!serverRunning) {
-		log("[spawnTmuxSession] SKIP: server not running", { serverUrl })
-		return { success: false }
-	}
-
-	const tmux = await getTmuxPath()
-	if (!tmux) {
-		log("[spawnTmuxSession] SKIP: tmux not found")
-		return { success: false }
-	}
-
-	log("[spawnTmuxSession] all checks passed, creating isolated session...")
-
-	const shell = process.env.SHELL || "/bin/sh"
-	const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl)
-	const escapedSessionId = shellEscapeForDoubleQuotedCommand(sessionId)
-	const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${escapedSessionId}"`
-
-	const sizeArgs: string[] = []
-	if (sourcePaneId) {
-		const dims = await getWindowDimensions(tmux, sourcePaneId)
-		if (dims) {
-			sizeArgs.push("-x", String(dims.width), "-y", String(dims.height))
-		}
-	}
-
-	const sessionAlreadyExists = await sessionExists(tmux, ISOLATED_SESSION_NAME)
-
-	const args = sessionAlreadyExists
-		? [
-			"new-window",
-			"-t", ISOLATED_SESSION_NAME,
-			"-P",
-			"-F", "#{pane_id}",
-			opencodeCmd,
-		]
-		: [
-			"new-session",
-			"-d",
-			"-s", ISOLATED_SESSION_NAME,
-			...sizeArgs,
-			"-P",
-			"-F", "#{pane_id}",
-			opencodeCmd,
-		]
-
-	log("[spawnTmuxSession] spawning", {
-		mode: sessionAlreadyExists ? "new-window" : "new-session",
-		sessionName: ISOLATED_SESSION_NAME,
-	})
-
-	const proc = spawn([tmux, ...args], { stdout: "pipe", stderr: "pipe" })
-	const exitCode = await proc.exited
-	const stdout = await new Response(proc.stdout).text()
-	const paneId = stdout.trim()
-
-	if (exitCode !== 0 || !paneId) {
-		const stderr = await new Response(proc.stderr).text()
-		log("[spawnTmuxSession] FAILED", { exitCode, stderr: stderr.trim() })
-		return { success: false }
-	}
-
-	const title = `omo-subagent-${description.slice(0, 20)}`
-	const titleProc = spawn([tmux, "select-pane", "-t", paneId, "-T", title], {
-		stdout: "ignore",
-		stderr: "pipe",
-	})
-	const stderrPromise = new Response(titleProc.stderr).text().catch(() => "")
-	const titleExitCode = await titleProc.exited
-	if (titleExitCode !== 0) {
-		const titleStderr = await stderrPromise
-		log("[spawnTmuxSession] WARNING: failed to set pane title", {
-			paneId,
-			title,
-			exitCode: titleExitCode,
-			stderr: titleStderr.trim(),
-		})
-	}
-
-	log("[spawnTmuxSession] SUCCESS", { paneId, sessionName: ISOLATED_SESSION_NAME })
-	return { success: true, paneId }
-}

package/src/shared/tmux/tmux-utils/window-spawn.ts

@@ -1,93 +0,0 @@
-import { spawn } from "bun"
-import type { TmuxConfig } from "../../../config/schema"
-import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"
-import type { SpawnPaneResult } from "../types"
-import { isInsideTmux } from "./environment"
-import { isServerRunning } from "./server-health"
-import { shellEscapeForDoubleQuotedCommand } from "../../shell-env"
-
-const ISOLATED_WINDOW_NAME = "omo-agents"
-
-export async function spawnTmuxWindow(
-	sessionId: string,
-	description: string,
-	config: TmuxConfig,
-	serverUrl: string,
-): Promise<SpawnPaneResult> {
-	const { log } = await import("../../logger")
-
-	log("[spawnTmuxWindow] called", {
-		sessionId,
-		description,
-		serverUrl,
-		configEnabled: config.enabled,
-	})
-
-	if (!config.enabled) {
-		log("[spawnTmuxWindow] SKIP: config.enabled is false")
-		return { success: false }
-	}
-	if (!isInsideTmux()) {
-		log("[spawnTmuxWindow] SKIP: not inside tmux", { TMUX: process.env.TMUX })
-		return { success: false }
-	}
-
-	const serverRunning = await isServerRunning(serverUrl)
-	if (!serverRunning) {
-		log("[spawnTmuxWindow] SKIP: server not running", { serverUrl })
-		return { success: false }
-	}
-
-	const tmux = await getTmuxPath()
-	if (!tmux) {
-		log("[spawnTmuxWindow] SKIP: tmux not found")
-		return { success: false }
-	}
-
-	log("[spawnTmuxWindow] all checks passed, creating isolated window...")
-
-	const shell = process.env.SHELL || "/bin/sh"
-	const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl)
-	const escapedSessionId = shellEscapeForDoubleQuotedCommand(sessionId)
-	const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${escapedSessionId}"`
-
-	const args = [
-		"new-window",
-		"-d",
-		"-n", ISOLATED_WINDOW_NAME,
-		"-P",
-		"-F", "#{pane_id}",
-		opencodeCmd,
-	]
-
-	const proc = spawn([tmux, ...args], { stdout: "pipe", stderr: "pipe" })
-	const exitCode = await proc.exited
-	const stdout = await new Response(proc.stdout).text()
-	const paneId = stdout.trim()
-
-	if (exitCode !== 0 || !paneId) {
-		const stderr = await new Response(proc.stderr).text()
-		log("[spawnTmuxWindow] FAILED", { exitCode, stderr: stderr.trim() })
-		return { success: false }
-	}
-
-	const title = `omo-subagent-${description.slice(0, 20)}`
-	const titleProc = spawn([tmux, "select-pane", "-t", paneId, "-T", title], {
-		stdout: "ignore",
-		stderr: "pipe",
-	})
-	const stderrPromise = new Response(titleProc.stderr).text().catch(() => "")
-	const titleExitCode = await titleProc.exited
-	if (titleExitCode !== 0) {
-		const titleStderr = await stderrPromise
-		log("[spawnTmuxWindow] WARNING: failed to set pane title", {
-			paneId,
-			title,
-			exitCode: titleExitCode,
-			stderr: titleStderr.trim(),
-		})
-	}
-
-	log("[spawnTmuxWindow] SUCCESS", { paneId, windowName: ISOLATED_WINDOW_NAME })
-	return { success: true, paneId }
-}

package/src/shared/tmux/tmux-utils.ts

@@ -1,15 +0,0 @@
-export { isInsideTmux, getCurrentPaneId } from "./tmux-utils/environment"
-export type { SplitDirection } from "./tmux-utils/environment"
-
-export { isServerRunning, resetServerCheck, markServerRunningInProcess } from "./tmux-utils/server-health"
-
-export { getPaneDimensions } from "./tmux-utils/pane-dimensions"
-export type { PaneDimensions } from "./tmux-utils/pane-dimensions"
-
-export { spawnTmuxPane } from "./tmux-utils/pane-spawn"
-export { closeTmuxPane } from "./tmux-utils/pane-close"
-export { replaceTmuxPane } from "./tmux-utils/pane-replace"
-export { spawnTmuxWindow } from "./tmux-utils/window-spawn"
-export { spawnTmuxSession } from "./tmux-utils/session-spawn"
-
-export { applyLayout, enforceMainPaneWidth } from "./tmux-utils/layout"

package/src/shared/tmux/types.ts

@@ -1,4 +0,0 @@
-export interface SpawnPaneResult {
-  success: boolean
-  paneId?: string  // e.g., "%42"
-}

package/src/shared/tool-name.ts

@@ -1,27 +0,0 @@
-const SPECIAL_TOOL_MAPPINGS: Record<string, string> = {
-  webfetch: "WebFetch",
-  websearch: "WebSearch",
-  todoread: "TodoRead",
-  todowrite: "TodoWrite",
-}
-
-function toPascalCase(str: string): string {
-  return str
-    .split(/[-_\s]+/)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join("")
-}
-
-export function transformToolName(toolName: string): string {
-  const trimmed = toolName.trim()
-  const lower = trimmed.toLowerCase()
-  if (lower in SPECIAL_TOOL_MAPPINGS) {
-    return SPECIAL_TOOL_MAPPINGS[lower]
-  }
-
-  if (trimmed.includes("-") || trimmed.includes("_")) {
-    return toPascalCase(trimmed)
-  }
-
-  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1)
-}

package/src/shared/truncate-description.ts

@@ -1,11 +0,0 @@
-export function truncateDescription(description: string, maxLength: number = 120): string {
-  if (!description) {
-    return description
-  }
-
-  if (description.length <= maxLength) {
-    return description
-  }
-
-  return description.slice(0, maxLength - 3) + "..."
-}

package/src/shared/vision-capable-models-cache.ts

@@ -1,17 +0,0 @@
-import type { VisionCapableModel } from "../plugin-state"
-
-let visionCapableModelsCache = new Map<string, VisionCapableModel>()
-
-export function setVisionCapableModelsCache(
-  cache: Map<string, VisionCapableModel>,
-): void {
-  visionCapableModelsCache = cache
-}
-
-export function readVisionCapableModelsCache(): VisionCapableModel[] {
-  return Array.from(visionCapableModelsCache.values())
-}
-
-export function clearVisionCapableModelsCache(): void {
-  visionCapableModelsCache = new Map<string, VisionCapableModel>()
-}

package/src/shared/write-file-atomically.ts

@@ -1,31 +0,0 @@
-import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs"
-
-export function writeFileAtomically(filePath: string, content: string): void {
-	const tempPath = `${filePath}.tmp`
-	writeFileSync(tempPath, content, "utf-8")
-
-  if (process.platform !== "win32") {
-    const tempFileDescriptor = openSync(tempPath, "r")
-    try {
-      fsyncSync(tempFileDescriptor)
-    } finally {
-      closeSync(tempFileDescriptor)
-    }
-  }
-
-  try {
-    renameSync(tempPath, filePath)
-  } catch (error) {
-    const isWindows = process.platform === "win32"
-    const isPermissionError =
-      error instanceof Error &&
-      (error.message.includes("EPERM") || error.message.includes("EACCES"))
-
-    if (isWindows && isPermissionError) {
-      unlinkSync(filePath)
-      renameSync(tempPath, filePath)
-    } else {
-      throw error
-    }
-  }
-}

package/src/shared/zip-entry-listing/powershell-zip-entry-listing.ts

@@ -1,99 +0,0 @@
-import { spawn } from "bun"
-
-import type { ArchiveEntry } from "../archive-entry-validator"
-
-export type PowerShellZipExtractor = "pwsh" | "powershell"
-
-type PowerShellZipEntryRecord = {
-	type: "file" | "directory" | "symlink"
-	name: string
-	target: string
-}
-
-function isPowerShellZipEntryRecord(value: unknown): value is PowerShellZipEntryRecord {
-	if (!value || typeof value !== "object") {
-		return false
-	}
-
-	const candidate = value as Record<string, unknown>
-	return (
-		(candidate.type === "file" || candidate.type === "directory" || candidate.type === "symlink") &&
-		typeof candidate.name === "string" &&
-		typeof candidate.target === "string"
-	)
-}
-
-export function parsePowerShellZipEntryLine(line: string): ArchiveEntry | null {
-	const parsedValue: unknown = JSON.parse(line)
-	if (!isPowerShellZipEntryRecord(parsedValue)) {
-		return null
-	}
-
-	if (parsedValue.type === "symlink") {
-		return {
-			path: parsedValue.name,
-			type: parsedValue.type,
-			linkPath: parsedValue.target,
-		}
-	}
-
-	return {
-		path: parsedValue.name,
-		type: parsedValue.type,
-	}
-}
-
-export async function listZipEntriesWithPowerShell(
-	archivePath: string,
-	escapePowerShellPath: (path: string) => string,
-	extractor: PowerShellZipExtractor
-): Promise<ArchiveEntry[]> {
-	const proc = spawn(
-			[
-				extractor,
-				"-Command",
-				[
-				"Add-Type -AssemblyName System.IO.Compression.FileSystem",
-				`$archive = [System.IO.Compression.ZipFile]::OpenRead('${escapePowerShellPath(archivePath)}')`,
-				"try {",
-				"  foreach ($entry in $archive.Entries) {",
-				"    $mode = ($entry.ExternalAttributes -shr 16) -band 0xFFFF",
-				"    $type = if (($mode -band 0xF000) -eq 0xA000) { 'symlink' } elseif ($entry.FullName.EndsWith('/')) { 'directory' } else { 'file' }",
-					"    $target = ''",
-					"    if ($type -eq 'symlink') {",
-					"      $stream = $entry.Open()",
-					"      try {",
-					"        $reader = New-Object System.IO.StreamReader($stream)",
-					"        try { $target = $reader.ReadToEnd() } finally { $reader.Dispose() }",
-					"      } finally { $stream.Dispose() }",
-					"    }",
-					"    Write-Output (ConvertTo-Json @{type=$type; name=$entry.FullName; target=$target} -Compress)",
-					"  }",
-					"} finally {",
-					"  $archive.Dispose()",
-					"}",
-			].join("; "),
-		],
-		{
-			stdout: "pipe",
-			stderr: "pipe",
-		}
-	)
-
-	const [exitCode, stdout, stderr] = await Promise.all([
-		proc.exited,
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-	])
-
-	if (exitCode !== 0) {
-		throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`)
-	}
-
-	return stdout
-		.split(/\r?\n/)
-		.map(line => line.trim())
-		.filter(Boolean)
-		.map(line => parsePowerShellZipEntryLine(line))
-		.filter((entry): entry is ArchiveEntry => entry !== null)
-}

package/src/shared/zip-entry-listing/python-zip-entry-listing.ts

@@ -1,55 +0,0 @@
-import { spawn, spawnSync } from "bun"
-
-import type { ArchiveEntry } from "../archive-entry-validator"
-
-export function isPythonZipListingAvailable(): boolean {
-	const proc = spawnSync(["python3", "--version"], {
-		stdout: "ignore",
-		stderr: "ignore",
-	})
-
-	return proc.exitCode === 0
-}
-
-export async function listZipEntriesWithPython(
-	archivePath: string
-): Promise<ArchiveEntry[]> {
-	const script = [
-		"import json, stat, sys, zipfile",
-		"entries = []",
-		"with zipfile.ZipFile(sys.argv[1], 'r') as archive:",
-		"    for info in archive.infolist():",
-		"        mode = (info.external_attr >> 16) & 0xFFFF",
-		"        if stat.S_ISLNK(mode):",
-		"            entry_type = 'symlink'",
-		"            link_path = archive.read(info).decode('utf-8', 'surrogateescape')",
-		"        elif info.filename.endswith('/'):",
-		"            entry_type = 'directory'",
-		"            link_path = None",
-		"        else:",
-		"            entry_type = 'file'",
-		"            link_path = None",
-		"        entry = {'path': info.filename, 'type': entry_type}",
-		"        if link_path is not None:",
-		"            entry['linkPath'] = link_path",
-		"        entries.append(entry)",
-		"print(json.dumps(entries))",
-	].join("\n")
-
-	const proc = spawn(["python3", "-c", script, archivePath], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-
-	const [exitCode, stdout, stderr] = await Promise.all([
-		proc.exited,
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-	])
-
-	if (exitCode !== 0) {
-		throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`)
-	}
-
-	return JSON.parse(stdout) as ArchiveEntry[]
-}

package/src/shared/zip-entry-listing/read-zip-symlink-target.ts

@@ -1,23 +0,0 @@
-import { spawn } from "bun"
-
-export async function readZipSymlinkTarget(
-	archivePath: string,
-	entryPath: string
-): Promise<string | undefined> {
-	const proc = spawn(["unzip", "-p", archivePath, "--", entryPath], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-
-	const [exitCode, stdout, stderr] = await Promise.all([
-		proc.exited,
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-	])
-
-	if (exitCode !== 0) {
-		throw new Error(`zip symlink target read failed (exit ${exitCode}): ${stderr}`)
-	}
-
-	return stdout || undefined
-}

package/src/shared/zip-entry-listing/tar-zip-entry-listing.ts

@@ -1,93 +0,0 @@
-import { spawn } from "bun"
-
-import type { ArchiveEntry } from "../archive-entry-validator"
-import { log } from "../logger"
-
-
-
-function parseTarListedZipEntry(line: string): ArchiveEntry | null {
-	const match = line.match(
-		/^([^\s])\S*\s+\d+\s+\S+\s+\S+\s+\d+\s+\w+\s+\d+\s+(?:\d{2}:\d{2}|\d{4})\s+(.*)$/
-	)
-	if (!match) {
-		return null
-	}
-
-	const [, rawType, rawEntryPath] = match
-	if (rawType === "l" || rawType === "h") {
-		const arrowIndex = rawEntryPath.lastIndexOf(" -> ")
-		return {
-			path: arrowIndex === -1 ? rawEntryPath : rawEntryPath.slice(0, arrowIndex),
-			type: rawType === "l" ? "symlink" : "hardlink",
-			linkPath: arrowIndex === -1 ? undefined : rawEntryPath.slice(arrowIndex + 4),
-		}
-	}
-
-	return {
-		path: rawEntryPath,
-		type: rawType === "d" ? "directory" : "file",
-	}
-}
-
-function validateParsedTarListing(
-	totalLineCount: number,
-	unparsedLines: string[]
-): void {
-	if (unparsedLines.length === 0) {
-		return
-	}
-
-	throw new Error(
-		`zip entry listing failed: ${unparsedLines.length}/${totalLineCount} tar listing lines could not be parsed (fail-closed)`
-	)
-}
-
-export function parseTarListingOutput(stdout: string): ArchiveEntry[] {
-	const listingLines = stdout
-		.split(/\r?\n/)
-		.map(line => line.trim())
-		.filter(Boolean)
-
-	if (listingLines.length === 0) {
-		return []
-	}
-
-	const parsedEntries: ArchiveEntry[] = []
-	const unparsedLines: string[] = []
-
-	for (const listingLine of listingLines) {
-		const parsedEntry = parseTarListedZipEntry(listingLine)
-		if (parsedEntry === null) {
-			unparsedLines.push(listingLine)
-			log("warning: unparsed tar listing line", { line: listingLine })
-			continue
-		}
-
-		parsedEntries.push(parsedEntry)
-	}
-
-	validateParsedTarListing(listingLines.length, unparsedLines)
-
-	return parsedEntries
-}
-
-export async function listZipEntriesWithTar(
-	archivePath: string
-): Promise<ArchiveEntry[]> {
-	const proc = spawn(["tar", "-tvf", archivePath], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-
-	const [exitCode, stdout, stderr] = await Promise.all([
-		proc.exited,
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-	])
-
-	if (exitCode !== 0) {
-		throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`)
-	}
-
-	return parseTarListingOutput(stdout)
-}

package/src/shared/zip-entry-listing/zipinfo-zip-entry-listing.ts

@@ -1,72 +0,0 @@
-import { spawn, spawnSync } from "bun"
-
-import type { ArchiveEntry } from "../archive-entry-validator"
-import { readZipSymlinkTarget } from "./read-zip-symlink-target"
-
-export function parseZipInfoListedEntry(line: string): ArchiveEntry | null {
-	const match = line.match(
-		/^([-dl?])\S*\s+\S+\s+\S+\s+\d+\s+\S+\s+\d+\s+\S+\s+\S+\s+\S+\s+(.*)$/
-	)
-	if (!match) {
-		return null
-	}
-
-	const [, rawType, rawEntryPath] = match
-	return {
-		path: rawEntryPath,
-		type: rawType === "d" ? "directory" : rawType === "l" ? "symlink" : "file",
-	}
-}
-
-export function isZipInfoZipListingAvailable(): boolean {
-	const proc = spawnSync(["which", "zipinfo"], {
-		stdout: "ignore",
-		stderr: "ignore",
-	})
-
-	return proc.exitCode === 0
-}
-
-function splitZipInfoOutputLines(stdout: string): string[] {
-	return stdout.split(/\r?\n/).filter(line => line.length > 0)
-}
-
-export async function listZipEntriesWithZipInfo(
-	archivePath: string
-): Promise<ArchiveEntry[]> {
-	if (!isZipInfoZipListingAvailable()) {
-		throw new Error("zip entry listing requires zipinfo, but zipinfo is not installed")
-	}
-
-	const proc = spawn(["zipinfo", "-l", archivePath], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-
-	const [exitCode, stdout, stderr] = await Promise.all([
-		proc.exited,
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-	])
-
-	if (exitCode !== 0) {
-		throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`)
-	}
-
-	const parsedEntries = splitZipInfoOutputLines(stdout)
-		.map(line => parseZipInfoListedEntry(line))
-		.filter((entry): entry is ArchiveEntry => entry !== null)
-
-	return Promise.all(
-		parsedEntries.map(async entry => {
-			if (entry.type !== "symlink") {
-				return entry
-			}
-
-			return {
-				...entry,
-				linkPath: await readZipSymlinkTarget(archivePath, entry.path),
-			}
-		})
-	)
-}