@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/shared/startup-diagnostics.ts

@@ -1,76 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-
-import type { HiaiOpenCodeConfig, HiaiOpencodeConfig } from "../config"
-import { HIAI_MCP_REGISTRY } from "../mcp/registry"
-import { parseJsoncSafe } from "./jsonc-parser"
-import { getOpenCodeConfigPaths } from "./opencode-config-dir"
-import { logWarn } from "./logger"
-import { PLUGIN_NAME } from "./plugin-identity"
-
-interface OpenCodeConfig {
-  plugin?: Array<string | [string, ...unknown[]]>
-}
-
-function readPlugins(configPath: string): string[] {
-  if (!existsSync(configPath)) return []
-
-  try {
-    const content = readFileSync(configPath, "utf-8")
-    const parsed = parseJsoncSafe<OpenCodeConfig>(content)
-    return (parsed.data?.plugin ?? [])
-      .map((entry) => typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : "")
-      .filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
-  } catch {
-    return []
-  }
-}
-
-export function warnIfListPluginEntry(directory: string): void {
-  const globalPaths = getOpenCodeConfigPaths({ binary: "opencode", version: null })
-  const candidates = [
-    join(directory, ".opencode", "opencode.json"),
-    join(directory, ".opencode", "opencode.jsonc"),
-    globalPaths.configJson,
-    globalPaths.configJsonc,
-  ]
-
-  for (const configPath of candidates) {
-    const plugins = readPlugins(configPath)
-    if (!plugins.includes("list")) continue
-
-    logWarn(`${configPath} contains plugin: ["list"].`)
-    logWarn("This can prevent hiai-opencode MCP servers from loading from that config scope.")
-    logWarn(`Update it to: plugin: ["${PLUGIN_NAME}"]`)
-  }
-}
-
-function hasConfigAuthFallback(pluginConfig: HiaiOpenCodeConfig, envName: string): boolean {
-  if (envName === "FIRECRAWL_API_KEY") return !!pluginConfig.auth?.firecrawl?.trim()
-  if (envName === "STITCH_AI_API_KEY") return !!pluginConfig.auth?.stitch?.trim()
-  if (envName === "CONTEXT7_API_KEY") return !!pluginConfig.auth?.context7?.trim()
-  return false
-}
-
-export function warnMissingRequiredMcpEnv(args: {
-  pluginConfig: HiaiOpenCodeConfig
-  platformConfig: HiaiOpencodeConfig
-}): void {
-  const disabled = new Set(args.pluginConfig.disabled_mcps ?? [])
-  const mcpConfig = args.platformConfig.mcp ?? {}
-
-  for (const [name, entry] of Object.entries(HIAI_MCP_REGISTRY)) {
-    if (disabled.has(name)) continue
-    if (mcpConfig[name]?.enabled === false) continue
-    if (!entry.requiredEnv || entry.requiredEnv.length === 0) continue
-
-    const missing = entry.requiredEnv.filter((envName) =>
-      !process.env[envName]?.trim() && !hasConfigAuthFallback(args.pluginConfig, envName)
-    )
-
-    if (missing.length === 0) continue
-
-    logWarn(`MCP "${name}" is enabled but missing required env: ${missing.join(", ")}.`
-      + " The plugin will continue to load; set the key or disable this MCP in hiai-opencode.json.")
-  }
-}

package/src/shared/system-directive.ts

@@ -1,67 +0,0 @@
-/**
- * Unified system directive prefix for hiai-opencode internal messages.
- * All system-generated messages should use this prefix for consistent filtering.
- *
- * Format: [SYSTEM DIRECTIVE: OH-MY-OPENCODE - {TYPE}]
- */
-
-export const SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: OH-MY-OPENCODE"
-
-const SYSTEM_DIRECTIVE_LEADING_KEYWORD_PATTERN = /^\s*(?:ultrawork|ulw)\s+/i
-
-/**
- * Creates a system directive header with the given type.
- * @param type - The directive type (e.g., "TODO CONTINUATION", "RALPH LOOP")
- * @returns Formatted directive string like "[SYSTEM DIRECTIVE: OH-MY-OPENCODE - TODO CONTINUATION]"
- */
-export function createSystemDirective(type: string): string {
-  return `${SYSTEM_DIRECTIVE_PREFIX} - ${type}]`
-}
-
-/**
- * Checks if a message starts with the hiai-opencode system directive prefix.
- * Used by keyword-detector and other hooks to skip system-generated messages.
- * @param text - The message text to check
- * @returns true if the message is a system directive
- */
-export function isSystemDirective(text: string): boolean {
-  const trimmed = text.trimStart()
-  if (trimmed.startsWith(SYSTEM_DIRECTIVE_PREFIX)) {
-    return true
-  }
-  const withoutLeadingKeyword = trimmed.replace(SYSTEM_DIRECTIVE_LEADING_KEYWORD_PATTERN, "")
-  return withoutLeadingKeyword.startsWith(SYSTEM_DIRECTIVE_PREFIX)
-}
-
-/**
- * Checks if a message contains system-generated content that should be excluded
- * from keyword detection and mode triggering.
- * @param text - The message text to check
- * @returns true if the message contains system-reminder tags
- */
-export function hasSystemReminder(text: string): boolean {
-  return /<system-reminder>[\s\S]*?<\/system-reminder>/i.test(text)
-}
-
-/**
- * Removes system-reminder tag content from text.
- * This prevents automated system messages from triggering mode keywords.
- * @param text - The message text to clean
- * @returns text with system-reminder content removed
- */
-export function removeSystemReminders(text: string): string {
-  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim()
-}
-
-export const SystemDirectiveTypes = {
-  TODO_CONTINUATION: "TODO CONTINUATION",
-  RALPH_LOOP: "RALPH LOOP",
-  BOULDER_CONTINUATION: "BOULDER CONTINUATION",
-  DELEGATION_REQUIRED: "DELEGATION REQUIRED",
-  SINGLE_TASK_ONLY: "SINGLE TASK ONLY",
-  COMPACTION_CONTEXT: "COMPACTION CONTEXT",
-  CONTEXT_WINDOW_MONITOR: "CONTEXT WINDOW MONITOR",
-  PROMETHEUS_READ_ONLY: "PROMETHEUS READ-ONLY",
-} as const
-
-export type SystemDirectiveType = (typeof SystemDirectiveTypes)[keyof typeof SystemDirectiveTypes]

package/src/shared/task-system-enabled.ts

@@ -1,9 +0,0 @@
-export interface TaskSystemConfig {
-  experimental?: {
-    task_system?: boolean
-  }
-}
-
-export function isTaskSystemEnabled(config: TaskSystemConfig): boolean {
-  return config.experimental?.task_system ?? false
-}

package/src/shared/tmux/constants.ts

@@ -1,12 +0,0 @@
-// Polling interval for background session status checks
-export const POLL_INTERVAL_BACKGROUND_MS = 2000
-
-// Maximum idle time before session considered stale
-export const SESSION_TIMEOUT_MS = 10 * 60 * 1000  // 10 minutes
-
-// Grace period for missing session before cleanup
-export const SESSION_MISSING_GRACE_MS = 6000  // 6 seconds
-
-// Session readiness polling config
-export const SESSION_READY_POLL_INTERVAL_MS = 500
-export const SESSION_READY_TIMEOUT_MS = 10_000  // 10 seconds max wait

package/src/shared/tmux/index.ts

@@ -1,3 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export * from "./tmux-utils"

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

@@ -1,13 +0,0 @@
-export type SplitDirection = "-h" | "-v"
-
-export function isInsideTmuxEnvironment(environment: Record<string, string | undefined>): boolean {
-  return Boolean(environment.TMUX)
-}
-
-export function isInsideTmux(): boolean {
-	return isInsideTmuxEnvironment(process.env)
-}
-
-export function getCurrentPaneId(): string | undefined {
-	return process.env.TMUX_PANE
-}

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

@@ -1,96 +0,0 @@
-import { spawn } from "bun"
-import type { TmuxLayout } from "../../../config/schema"
-import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"
-
-type TmuxSpawnCommand = (
-	args: string[],
-	options: { stdout: "ignore"; stderr: "ignore" },
-) => { exited: Promise<number> }
-
-interface LayoutDeps {
-	spawnCommand?: TmuxSpawnCommand
-}
-
-interface MainPaneWidthOptions {
-	mainPaneSize?: number
-	mainPaneMinWidth?: number
-	agentPaneMinWidth?: number
-}
-
-function clamp(value: number, min: number, max: number): number {
-	return Math.max(min, Math.min(max, value))
-}
-
-function calculateMainPaneWidth(
-	windowWidth: number,
-	options?: MainPaneWidthOptions,
-): number {
-	const dividerWidth = 1
-	const sizePercent = clamp(options?.mainPaneSize ?? 50, 20, 80)
-	const minMainPaneWidth = options?.mainPaneMinWidth ?? 0
-	const minAgentPaneWidth = options?.agentPaneMinWidth ?? 0
-	const desiredMainPaneWidth = Math.floor(
-		(windowWidth - dividerWidth) * (sizePercent / 100),
-	)
-	const maxMainPaneWidth = Math.max(
-		0,
-		windowWidth - dividerWidth - minAgentPaneWidth,
-	)
-
-	return clamp(Math.max(desiredMainPaneWidth, minMainPaneWidth), 0, maxMainPaneWidth)
-}
-
-export async function applyLayout(
-	tmux: string,
-	layout: TmuxLayout,
-	mainPaneSize: number,
-	deps?: LayoutDeps,
-): Promise<void> {
-	const spawnCommand: TmuxSpawnCommand = deps?.spawnCommand ?? spawn
-	const layoutProc = spawnCommand([tmux, "select-layout", layout], {
-		stdout: "ignore",
-		stderr: "ignore",
-	})
-	await layoutProc.exited
-
-	if (layout.startsWith("main-")) {
-		const dimension =
-			layout === "main-horizontal" ? "main-pane-height" : "main-pane-width"
-		const sizeProc = spawnCommand(
-			[tmux, "set-window-option", dimension, `${mainPaneSize}%`],
-			{ stdout: "ignore", stderr: "ignore" },
-		)
-		await sizeProc.exited
-	}
-}
-
-export async function enforceMainPaneWidth(
-	mainPaneId: string,
-	windowWidth: number,
-	mainPaneSizeOrOptions?: number | MainPaneWidthOptions,
-): Promise<void> {
-	const { log } = await import("../../logger")
-	const tmux = await getTmuxPath()
-	if (!tmux) return
-
-	const options: MainPaneWidthOptions =
-		typeof mainPaneSizeOrOptions === "number"
-			? { mainPaneSize: mainPaneSizeOrOptions }
-			: mainPaneSizeOrOptions ?? {}
-	const mainWidth = calculateMainPaneWidth(windowWidth, options)
-
-	const proc = spawn([tmux, "resize-pane", "-t", mainPaneId, "-x", String(mainWidth)], {
-		stdout: "ignore",
-		stderr: "ignore",
-	})
-	await proc.exited
-
-	log("[enforceMainPaneWidth] main pane resized", {
-		mainPaneId,
-		mainWidth,
-		windowWidth,
-		mainPaneSize: options?.mainPaneSize,
-		mainPaneMinWidth: options?.mainPaneMinWidth,
-		agentPaneMinWidth: options?.agentPaneMinWidth,
-	})
-}

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

@@ -1,48 +0,0 @@
-import { spawn } from "bun"
-import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"
-import { isInsideTmux } from "./environment"
-
-function delay(milliseconds: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, milliseconds))
-}
-
-export async function closeTmuxPane(paneId: string): Promise<boolean> {
-	const { log } = await import("../../logger")
-
-	if (!isInsideTmux()) {
-		log("[closeTmuxPane] SKIP: not inside tmux")
-		return false
-	}
-
-	const tmux = await getTmuxPath()
-	if (!tmux) {
-		log("[closeTmuxPane] SKIP: tmux not found")
-		return false
-	}
-
-	log("[closeTmuxPane] sending Ctrl+C for graceful shutdown", { paneId })
-	const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await ctrlCProc.exited
-
-	await delay(250)
-
-	log("[closeTmuxPane] killing pane", { paneId })
-
-	const proc = spawn([tmux, "kill-pane", "-t", paneId], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const exitCode = await proc.exited
-	const stderr = await new Response(proc.stderr).text()
-
-	if (exitCode !== 0) {
-		log("[closeTmuxPane] FAILED", { paneId, exitCode, stderr: stderr.trim() })
-	} else {
-		log("[closeTmuxPane] SUCCESS", { paneId })
-	}
-
-	return exitCode === 0
-}

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

@@ -1,28 +0,0 @@
-import { spawn } from "bun"
-import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"
-
-export interface PaneDimensions {
-	paneWidth: number
-	windowWidth: number
-}
-
-export async function getPaneDimensions(
-	paneId: string,
-): Promise<PaneDimensions | null> {
-	const tmux = await getTmuxPath()
-	if (!tmux) return null
-
-	const proc = spawn(
-		[tmux, "display", "-p", "-t", paneId, "#{pane_width},#{window_width}"],
-		{ stdout: "pipe", stderr: "pipe" },
-	)
-	const exitCode = await proc.exited
-	const stdout = await new Response(proc.stdout).text()
-
-	if (exitCode !== 0) return null
-
-	const [paneWidth, windowWidth] = stdout.trim().split(",").map(Number)
-	if (Number.isNaN(paneWidth) || Number.isNaN(windowWidth)) return null
-
-	return { paneWidth, windowWidth }
-}

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

@@ -1,73 +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 { shellEscapeForDoubleQuotedCommand } from "../../shell-env"
-
-export async function replaceTmuxPane(
-	paneId: string,
-	sessionId: string,
-	description: string,
-	config: TmuxConfig,
-	serverUrl: string,
-): Promise<SpawnPaneResult> {
-	const { log } = await import("../../logger")
-
-	log("[replaceTmuxPane] called", { paneId, sessionId, description })
-
-	if (!config.enabled) {
-		return { success: false }
-	}
-	if (!isInsideTmux()) {
-		return { success: false }
-	}
-
-	const tmux = await getTmuxPath()
-	if (!tmux) {
-		return { success: false }
-	}
-
-	log("[replaceTmuxPane] sending Ctrl+C for graceful shutdown", { paneId })
-	const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	await ctrlCProc.exited
-
-	const shell = process.env.SHELL || "/bin/sh"
-	const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl)
-	const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${sessionId}"`
-
-	const proc = spawn([tmux, "respawn-pane", "-k", "-t", paneId, opencodeCmd], {
-		stdout: "pipe",
-		stderr: "pipe",
-	})
-	const exitCode = await proc.exited
-
-	if (exitCode !== 0) {
-		const stderr = await new Response(proc.stderr).text()
-		log("[replaceTmuxPane] FAILED", { paneId, 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("[replaceTmuxPane] WARNING: failed to set pane title", {
-			paneId,
-			title,
-			exitCode: titleExitCode,
-			stderr: titleStderr.trim(),
-		})
-	}
-
-	log("[replaceTmuxPane] SUCCESS", { paneId, sessionId })
-	return { success: true, paneId }
-}

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

@@ -1,94 +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 type { SplitDirection } from "./environment"
-import { isInsideTmux } from "./environment"
-import { isServerRunning } from "./server-health"
-import { shellEscapeForDoubleQuotedCommand } from "../../shell-env"
-
-export async function spawnTmuxPane(
-	sessionId: string,
-	description: string,
-	config: TmuxConfig,
-	serverUrl: string,
-	targetPaneId?: string,
-	splitDirection: SplitDirection = "-h",
-): Promise<SpawnPaneResult> {
-	const { log } = await import("../../logger")
-
-	log("[spawnTmuxPane] called", {
-		sessionId,
-		description,
-		serverUrl,
-		configEnabled: config.enabled,
-		targetPaneId,
-		splitDirection,
-	})
-
-	if (!config.enabled) {
-		log("[spawnTmuxPane] SKIP: config.enabled is false")
-		return { success: false }
-	}
-	if (!isInsideTmux()) {
-		log("[spawnTmuxPane] SKIP: not inside tmux", { TMUX: process.env.TMUX })
-		return { success: false }
-	}
-
-	const serverRunning = await isServerRunning(serverUrl)
-	if (!serverRunning) {
-		log("[spawnTmuxPane] SKIP: server not running", { serverUrl })
-		return { success: false }
-	}
-
-	const tmux = await getTmuxPath()
-	if (!tmux) {
-		log("[spawnTmuxPane] SKIP: tmux not found")
-		return { success: false }
-	}
-
-	log("[spawnTmuxPane] all checks passed, spawning...")
-
-	const shell = process.env.SHELL || "/bin/sh"
-	const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl)
-	const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${sessionId}"`
-
-	const args = [
-		"split-window",
-		splitDirection,
-		"-d",
-		"-P",
-		"-F",
-		"#{pane_id}",
-		...(targetPaneId ? ["-t", targetPaneId] : []),
-		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) {
-		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("[spawnTmuxPane] WARNING: failed to set pane title", {
-			paneId,
-			title,
-			exitCode: titleExitCode,
-			stderr: titleStderr.trim(),
-		})
-	}
-
-	return { success: true, paneId }
-}

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

@@ -1,62 +0,0 @@
-let serverAvailable: boolean | null = null
-let serverCheckUrl: string | null = null
-
-const SERVER_RUNNING_KEY = Symbol.for("hiai-opencode:server-running-in-process")
-
-function delay(milliseconds: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, milliseconds))
-}
-
-export function markServerRunningInProcess(): void {
-	;(globalThis as Record<symbol, boolean>)[SERVER_RUNNING_KEY] = true
-}
-
-function isMarkedRunningInProcess(): boolean {
-	return (globalThis as Record<symbol, boolean>)[SERVER_RUNNING_KEY] === true
-}
-
-export async function isServerRunning(serverUrl: string): Promise<boolean> {
-	if (isMarkedRunningInProcess()) {
-		return true
-	}
-
-	if (serverCheckUrl === serverUrl && serverAvailable === true) {
-		return true
-	}
-
-	const healthUrl = new URL("/global/health", serverUrl).toString()
-	const timeoutMs = 3000
-	const maxAttempts = 2
-
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-		const controller = new AbortController()
-		const timeout = setTimeout(() => controller.abort(), timeoutMs)
-
-		try {
-			const response = await fetch(healthUrl, {
-				signal: controller.signal,
-			}).catch(() => null)
-			clearTimeout(timeout)
-
-			if (response?.ok) {
-				serverCheckUrl = serverUrl
-				serverAvailable = true
-				return true
-			}
-		} finally {
-			clearTimeout(timeout)
-		}
-
-		if (attempt < maxAttempts) {
-			await delay(250)
-		}
-	}
-
-	return false
-}
-
-export function resetServerCheck(): void {
-	serverAvailable = null
-	serverCheckUrl = null
-	delete (globalThis as Record<symbol, boolean>)[SERVER_RUNNING_KEY]
-}