@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/shared/session-cursor.ts

@@ -1,108 +0,0 @@
-type MessageTime =
-  | { created?: number | string }
-  | number
-  | string
-  | undefined
-
-type MessageInfo = {
-  id?: string
-  time?: MessageTime
-}
-
-export type CursorMessage = {
-  info?: MessageInfo
-}
-
-export interface CursorState {
-  lastKey?: string
-  lastCount: number
-}
-
-const sessionCursors = new Map<string, CursorState>()
-
-function cloneCursorState(state: CursorState | undefined): CursorState | undefined {
-  if (!state) return undefined
-  return {
-    lastKey: state.lastKey,
-    lastCount: state.lastCount,
-  }
-}
-
-function buildMessageKey(message: CursorMessage, index: number): string {
-  const id = message.info?.id
-  if (id) return `id:${id}`
-
-  const time = message.info?.time
-  if (typeof time === "number" || typeof time === "string") {
-    return `t:${time}:${index}`
-  }
-
-  const created = time?.created
-  if (typeof created === "number") {
-    return `t:${created}:${index}`
-  }
-  if (typeof created === "string") {
-    return `t:${created}:${index}`
-  }
-
-  return `i:${index}`
-}
-
-export function consumeNewMessages<T extends CursorMessage>(
-  sessionID: string | undefined,
-  messages: T[]
-): T[] {
-  if (!sessionID) return messages
-
-  const keys = messages.map((message, index) => buildMessageKey(message, index))
-  const cursor = sessionCursors.get(sessionID)
-  let startIndex = 0
-
-  if (cursor) {
-    if (cursor.lastCount > messages.length) {
-      startIndex = 0
-    } else if (cursor.lastKey) {
-      const lastIndex = keys.lastIndexOf(cursor.lastKey)
-      if (lastIndex >= 0) {
-        startIndex = lastIndex + 1
-      } else {
-        // History changed without a shrink; reset to avoid skipping messages.
-        startIndex = 0
-      }
-    }
-  }
-
-  if (messages.length === 0) {
-    sessionCursors.delete(sessionID)
-  } else {
-    sessionCursors.set(sessionID, {
-      lastKey: keys[keys.length - 1],
-      lastCount: messages.length,
-    })
-  }
-
-  return messages.slice(startIndex)
-}
-
-export function resetMessageCursor(sessionID?: string): void {
-  if (sessionID) {
-    sessionCursors.delete(sessionID)
-    return
-  }
-  sessionCursors.clear()
-}
-
-export function getMessageCursor(sessionID: string | undefined): CursorState | undefined {
-  if (!sessionID) return undefined
-  return cloneCursorState(sessionCursors.get(sessionID))
-}
-
-export function restoreMessageCursor(sessionID: string | undefined, cursor: CursorState | undefined): void {
-  if (!sessionID) return
-  if (!cursor) {
-    sessionCursors.delete(sessionID)
-    return
-  }
-
-  sessionCursors.set(sessionID, cloneCursorState(cursor)!)
-}

package/src/shared/session-directory-resolver.ts

@@ -1,41 +0,0 @@
-const WINDOWS_APPDATA_SEGMENTS = ["\\appdata\\local", "\\appdata\\roaming", "\\appdata\\locallow"]
-
-function normalizeWindowsPath(directory: string): string {
-  return directory.replaceAll("/", "\\").toLowerCase()
-}
-
-export function isWindowsAppDataDirectory(directory: string): boolean {
-  const normalizedDirectory = normalizeWindowsPath(directory)
-  return WINDOWS_APPDATA_SEGMENTS.some((segment) => {
-    return normalizedDirectory.endsWith(segment) || normalizedDirectory.includes(`${segment}\\`)
-  })
-}
-
-export function resolveSessionDirectory(options: {
-  parentDirectory: string | null | undefined
-  fallbackDirectory: string
-  platform?: NodeJS.Platform
-  currentWorkingDirectory?: string
-}): string {
-  const {
-    parentDirectory,
-    fallbackDirectory,
-    platform = process.platform,
-    currentWorkingDirectory = process.cwd(),
-  } = options
-
-  const sessionDirectory = parentDirectory ?? fallbackDirectory
-  if (platform !== "win32") {
-    return sessionDirectory
-  }
-
-  if (!isWindowsAppDataDirectory(sessionDirectory)) {
-    return sessionDirectory
-  }
-
-  if (isWindowsAppDataDirectory(currentWorkingDirectory)) {
-    return sessionDirectory
-  }
-
-  return currentWorkingDirectory
-}

package/src/shared/session-injected-paths.ts

@@ -1,59 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-
-export interface InjectedPathsData {
-  sessionID: string;
-  injectedPaths: string[];
-  updatedAt: number;
-}
-
-export function createInjectedPathsStorage(storageDir: string) {
-  const getStoragePath = (sessionID: string): string =>
-    join(storageDir, `${sessionID}.json`);
-
-  const loadInjectedPaths = (sessionID: string): Set<string> => {
-    const filePath = getStoragePath(sessionID);
-    if (!existsSync(filePath)) return new Set();
-
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const data: InjectedPathsData = JSON.parse(content);
-      return new Set(data.injectedPaths);
-    } catch {
-      return new Set();
-    }
-  };
-
-  const saveInjectedPaths = (sessionID: string, paths: Set<string>): void => {
-    if (!existsSync(storageDir)) {
-      mkdirSync(storageDir, { recursive: true });
-    }
-
-    const data: InjectedPathsData = {
-      sessionID,
-      injectedPaths: [...paths],
-      updatedAt: Date.now(),
-    };
-
-    writeFileSync(getStoragePath(sessionID), JSON.stringify(data, null, 2));
-  };
-
-  const clearInjectedPaths = (sessionID: string): void => {
-    const filePath = getStoragePath(sessionID);
-    if (existsSync(filePath)) {
-      unlinkSync(filePath);
-    }
-  };
-
-  return {
-    loadInjectedPaths,
-    saveInjectedPaths,
-    clearInjectedPaths,
-  };
-}

package/src/shared/session-model-state.ts

@@ -1,15 +0,0 @@
-export type SessionModel = { providerID: string; modelID: string }
-
-const sessionModels = new Map<string, SessionModel>()
-
-export function setSessionModel(sessionID: string, model: SessionModel): void {
-  sessionModels.set(sessionID, model)
-}
-
-export function getSessionModel(sessionID: string): SessionModel | undefined {
-  return sessionModels.get(sessionID)
-}
-
-export function clearSessionModel(sessionID: string): void {
-  sessionModels.delete(sessionID)
-}

package/src/shared/session-prompt-params-helpers.ts

@@ -1,31 +0,0 @@
-import { clearSessionPromptParams, setSessionPromptParams } from "./session-prompt-params-state"
-
-type PromptParamModel = {
-  temperature?: number
-  top_p?: number
-  reasoningEffort?: string
-  maxTokens?: number
-  thinking?: { type: "enabled" | "disabled"; budgetTokens?: number }
-}
-
-export function applySessionPromptParams(
-  sessionID: string,
-  model: PromptParamModel | undefined,
-): void {
-  if (!model) {
-    clearSessionPromptParams(sessionID)
-    return
-  }
-
-  const promptOptions: Record<string, unknown> = {
-    ...(model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}),
-    ...(model.thinking ? { thinking: model.thinking } : {}),
-  }
-
-  setSessionPromptParams(sessionID, {
-    ...(model.temperature !== undefined ? { temperature: model.temperature } : {}),
-    ...(model.top_p !== undefined ? { topP: model.top_p } : {}),
-    ...(model.maxTokens !== undefined ? { maxOutputTokens: model.maxTokens } : {}),
-    ...(Object.keys(promptOptions).length > 0 ? { options: promptOptions } : {}),
-  })
-}

package/src/shared/session-prompt-params-state.ts

@@ -1,37 +0,0 @@
-export type SessionPromptParams = {
-  temperature?: number
-  topP?: number
-  maxOutputTokens?: number
-  options?: Record<string, unknown>
-}
-
-const sessionPromptParams = new Map<string, SessionPromptParams>()
-
-export function setSessionPromptParams(sessionID: string, params: SessionPromptParams): void {
-  sessionPromptParams.set(sessionID, {
-    ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
-    ...(params.topP !== undefined ? { topP: params.topP } : {}),
-    ...(params.maxOutputTokens !== undefined ? { maxOutputTokens: params.maxOutputTokens } : {}),
-    ...(params.options !== undefined ? { options: { ...params.options } } : {}),
-  })
-}
-
-export function getSessionPromptParams(sessionID: string): SessionPromptParams | undefined {
-  const params = sessionPromptParams.get(sessionID)
-  if (!params) return undefined
-
-  return {
-    ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
-    ...(params.topP !== undefined ? { topP: params.topP } : {}),
-    ...(params.maxOutputTokens !== undefined ? { maxOutputTokens: params.maxOutputTokens } : {}),
-    ...(params.options !== undefined ? { options: { ...params.options } } : {}),
-  }
-}
-
-export function clearSessionPromptParams(sessionID: string): void {
-  sessionPromptParams.delete(sessionID)
-}
-
-export function clearAllSessionPromptParams(): void {
-  sessionPromptParams.clear()
-}

package/src/shared/session-tools-store.ts

@@ -1,18 +0,0 @@
-const store = new Map<string, Record<string, boolean>>();
-
-export function setSessionTools(sessionID: string, tools: Record<string, boolean>): void {
-  store.set(sessionID, { ...tools });
-}
-
-export function getSessionTools(sessionID: string): Record<string, boolean> | undefined {
-  const tools = store.get(sessionID);
-  return tools ? { ...tools } : undefined;
-}
-
-export function deleteSessionTools(sessionID: string): void {
-  store.delete(sessionID);
-}
-
-export function clearSessionTools(): void {
-  store.clear();
-}

package/src/shared/session-utils.ts

@@ -1,25 +0,0 @@
-import { findNearestMessageWithFields, findNearestMessageWithFieldsFromSDK } from "../features/hook-message-injector"
-import { getMessageDir } from "./opencode-message-dir"
-import { isSqliteBackend } from "./opencode-storage-detection"
-import { log } from "./logger"
-import { getAgentConfigKey } from "./agent-display-names"
-import type { PluginInput } from "@opencode-ai/plugin"
-
-export async function isCallerOrchestrator(sessionID?: string, client?: PluginInput["client"]): Promise<boolean> {
-  if (!sessionID) return false
-
-  if (isSqliteBackend() && client) {
-    try {
-      const nearest = await findNearestMessageWithFieldsFromSDK(client, sessionID)
-      return getAgentConfigKey(nearest?.agent ?? "") === "guard"
-    } catch (error) {
-      log("[session-utils] SDK orchestrator check failed", { sessionID, error: String(error) })
-      return false
-    }
-  }
-
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return false
-  const nearest = findNearestMessageWithFields(messageDir)
-  return getAgentConfigKey(nearest?.agent ?? "") === "guard"
-}

package/src/shared/shell-env.ts

@@ -1,175 +0,0 @@
-export type ShellType = "unix" | "powershell" | "cmd" | "csh"
-
-/**
- * Detect the current shell type based on environment variables.
- * 
- * Detection priority:
- * 1. SHELL env var → Unix shell (explicit user choice takes precedence)
- * 2. PSModulePath → PowerShell
- * 3. Platform fallback → win32: cmd, others: unix
- * 
- * Note: SHELL is checked before PSModulePath because on Windows, PSModulePath
- * is always set by the system even when the active shell is Git Bash or WSL.
- * An explicit SHELL variable indicates the user's chosen shell overrides that.
- */
-export function detectShellType(): ShellType {
-  if (process.env.SHELL) {
-    const shell = process.env.SHELL
-    if (shell.includes("csh") || shell.includes("tcsh")) {
-      return "csh"
-    }
-    return "unix"
-  }
-
-  // Git Bash on Windows sets MSYSTEM (e.g. "MINGW64", "MINGW32", "MSYS")
-  // even when SHELL is not set. Detect this before PSModulePath which is
-  // always present on Windows regardless of the active shell.
-  if (process.env.MSYSTEM) {
-    return "unix"
-  }
-
-  if (process.env.PSModulePath) {
-    return "powershell"
-  }
-
-  return process.platform === "win32" ? "cmd" : "unix"
-}
-
-/**
- * Shell-escape a value for use in environment variable assignment.
- * 
- * @param value - The value to escape
- * @param shellType - The target shell type
- * @returns Escaped value appropriate for the shell
- */
-export function shellEscape(value: string, shellType: ShellType): string {
-  if (value === "") {
-    return shellType === "cmd" ? '""' : "''"
-  }
-
-  switch (shellType) {
-    case "unix":
-    case "csh":
-      if (/[^a-zA-Z0-9_\-.:\/]/.test(value)) {
-        return `'${value.replace(/'/g, "'\\''")}'`
-      }
-      return value
-
-    case "powershell":
-      return `'${value.replace(/'/g, "''")}'`
-
-    case "cmd":
-      // Escape % first (for environment variable expansion), then " (for quoting)
-      return `"${value.replace(/%/g, '%%').replace(/"/g, '""')}"`
-
-    default:
-      return value
-  }
-}
-
-/**
- * Build environment variable prefix command for the target shell.
- * 
- * @param env - Record of environment variables to set
- * @param shellType - The target shell type
- * @returns Command prefix string to prepend to the actual command
- * 
- * @example
- * ```ts
- * // Unix: "export VAR1=val1 VAR2=val2; command"
- * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "unix")
- * // => "export VAR1=val1 VAR2=val2;"
- * 
- * // PowerShell: "$env:VAR1='val1'; $env:VAR2='val2'; command"
- * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "powershell")
- * // => "$env:VAR1='val1'; $env:VAR2='val2';"
- * 
- * // cmd.exe: "set VAR1=val1 && set VAR2=val2 && command"
- * buildEnvPrefix({ VAR1: "val1", VAR2: "val2" }, "cmd")
- * // => "set VAR1=\"val1\" && set VAR2=\"val2\" &&"
- * ```
- */
-export function buildEnvPrefix(
-  env: Record<string, string>,
-  shellType: ShellType
-): string {
-  const entries = Object.entries(env)
-  
-  if (entries.length === 0) {
-    return ""
-  }
-
-  switch (shellType) {
-    case "unix": {
-      const assignments = entries
-        .map(([key, value]) => `${key}=${shellEscape(value, shellType)}`)
-        .join(" ")
-      return `export ${assignments};`
-    }
-
-    case "csh": {
-      const assignments = entries
-        .map(([key, value]) => `setenv ${key} ${shellEscape(value, shellType)}`)
-        .join("; ")
-      return `${assignments};`
-    }
-
-    case "powershell": {
-      const assignments = entries
-        .map(([key, value]) => `$env:${key}=${shellEscape(value, shellType)}`)
-        .join("; ")
-      return `${assignments};`
-    }
-
-    case "cmd": {
-      const assignments = entries
-        .map(([key, value]) => `set ${key}=${shellEscape(value, shellType)}`)
-        .join(" && ")
-      return `${assignments} &&`
-    }
-
-    default:
-      return ""
-  }
-}
-
-/**
- * Escape a value for use in a double-quoted shell -c command argument.
- * 
- * In shell -c "..." strings, these characters have special meaning and must be escaped:
- * - $ - variable expansion, command substitution $(...)
- * - ` - command substitution `...`
- * - \\ - escape character
- * - " - end quote
- * - ; | & - command separators
- * - # - comment
- * - () - grouping operators
- * 
- * @param value - The value to escape
- * @returns Escaped value safe for double-quoted shell -c argument
- * 
- * @example
- * ```ts
- * // For malicious input
- * const url = "http://localhost:3000'; cat /etc/passwd; echo '"
- * const escaped = shellEscapeForDoubleQuotedCommand(url)
- * // => "http://localhost:3000'\''; cat /etc/passwd; echo '"
- * 
- * // Usage in command:
- * const cmd = `/bin/sh -c "opencode attach ${escaped} --session ${sessionId}"`
- * ```
- */
-export function shellEscapeForDoubleQuotedCommand(value: string): string {
-  // Order matters: escape backslash FIRST, then other characters
-  return value
-    .replace(/\\/g, "\\\\") // escape backslash first
-    .replace(/\$/g, "\\$") // escape dollar sign
-    .replace(/`/g, "\\`") // escape backticks
-    .replace(/"/g, "\\\"") // escape double quotes
-    .replace(/;/g, "\\;") // escape semicolon (command separator)
-    .replace(/\|/g, "\\|") // escape pipe (command separator)
-    .replace(/&/g, "\\&") // escape ampersand (command separator)
-    .replace(/#/g, "\\#") // escape hash (comment)
-    .replace(/\(/g, "\\(") // escape parentheses
-    .replace(/\)/g, "\\)") // escape parentheses
-}

package/src/shared/skill-path-resolver.ts

@@ -1,26 +0,0 @@
-import { isAbsolute, relative, resolve, sep } from "node:path"
-
-function looksLikeFilePath(path: string): boolean {
-	if (path.endsWith("/")) return true
-	const lastSegment = path.split("/").pop() ?? ""
-	return /\.[a-zA-Z0-9]+$/.test(lastSegment)
-}
-
-export function resolveSkillPathReferences(content: string, basePath: string): string {
-	const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath
-	return content.replace(
-		/(?<![a-zA-Z0-9="\(])@([a-zA-Z0-9_-]+\/[a-zA-Z0-9_.\-\/]*)/g,
-		(match, relativePath: string) => {
-			if (!looksLikeFilePath(relativePath)) return match
-			const resolvedPath = resolve(normalizedBase, relativePath)
-			const relativePathFromBase = relative(normalizedBase, resolvedPath)
-			if (relativePathFromBase.startsWith("..") || isAbsolute(relativePathFromBase)) {
-				return match
-			}
-			if (relativePath.endsWith("/") && !resolvedPath.endsWith(sep)) {
-				return `${resolvedPath}/`
-			}
-			return resolvedPath
-		}
-	)
-}

package/src/shared/snake-case.ts

@@ -1,44 +0,0 @@
-import { isPlainObject } from "./deep-merge"
-
-export function camelToSnake(str: string): string {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)
-}
-
-export function snakeToCamel(str: string): string {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
-}
-
-export function transformObjectKeys(
-  obj: Record<string, unknown>,
-  transformer: (key: string) => string,
-  deep: boolean = true
-): Record<string, unknown> {
-  const result: Record<string, unknown> = {}
-  for (const [key, value] of Object.entries(obj)) {
-    const transformedKey = transformer(key)
-    if (deep && isPlainObject(value)) {
-      result[transformedKey] = transformObjectKeys(value, transformer, true)
-    } else if (deep && Array.isArray(value)) {
-      result[transformedKey] = value.map((item) =>
-        isPlainObject(item) ? transformObjectKeys(item, transformer, true) : item
-      )
-    } else {
-      result[transformedKey] = value
-    }
-  }
-  return result
-}
-
-export function objectToSnakeCase(
-  obj: Record<string, unknown>,
-  deep: boolean = true
-): Record<string, unknown> {
-  return transformObjectKeys(obj, camelToSnake, deep)
-}
-
-export function objectToCamelCase(
-  obj: Record<string, unknown>,
-  deep: boolean = true
-): Record<string, unknown> {
-  return transformObjectKeys(obj, snakeToCamel, deep)
-}

package/src/shared/spawn-with-windows-hide.ts

@@ -1,84 +0,0 @@
-import { spawn as bunSpawn } from "bun"
-import { spawn as nodeSpawn, type ChildProcess } from "node:child_process"
-import { Readable } from "node:stream"
-
-export interface SpawnOptions {
-  cwd?: string
-  env?: Record<string, string | undefined>
-  stdin?: "pipe" | "inherit" | "ignore"
-  stdout?: "pipe" | "inherit" | "ignore"
-  stderr?: "pipe" | "inherit" | "ignore"
-}
-
-export interface SpawnedProcess {
-  readonly exitCode: number | null
-  readonly exited: Promise<number>
-  readonly stdout: ReadableStream<Uint8Array> | undefined
-  readonly stderr: ReadableStream<Uint8Array> | undefined
-  kill(signal?: NodeJS.Signals): void
-}
-
-function toReadableStream(stream: NodeJS.ReadableStream | null): ReadableStream<Uint8Array> | undefined {
-  if (!stream) {
-    return undefined
-  }
-
-  return Readable.toWeb(stream as Readable) as unknown as ReadableStream<Uint8Array>
-}
-
-function wrapNodeProcess(proc: ChildProcess): SpawnedProcess {
-  let resolveExited: (exitCode: number) => void
-  let exitCode: number | null = null
-
-  const exited = new Promise<number>((resolve) => {
-    resolveExited = resolve
-  })
-
-  proc.on("exit", (code) => {
-    exitCode = code ?? 1
-    resolveExited(exitCode)
-  })
-
-  proc.on("error", () => {
-    if (exitCode === null) {
-      exitCode = 1
-      resolveExited(1)
-    }
-  })
-
-  return {
-    get exitCode() {
-      return exitCode
-    },
-    exited,
-    stdout: toReadableStream(proc.stdout),
-    stderr: toReadableStream(proc.stderr),
-    kill(signal?: NodeJS.Signals): void {
-      try {
-        if (!signal) {
-          proc.kill()
-          return
-        }
-
-        proc.kill(signal)
-      } catch {}
-    },
-  }
-}
-
-export function spawnWithWindowsHide(command: string[], options: SpawnOptions): SpawnedProcess {
-  if (process.platform !== "win32") {
-    return bunSpawn(command, options)
-  }
-
-  const [cmd, ...args] = command
-  const proc = nodeSpawn(cmd, args, {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: [options.stdin ?? "pipe", options.stdout ?? "pipe", options.stderr ?? "pipe"],
-    windowsHide: true,
-    shell: true,
-  })
-
-  return wrapNodeProcess(proc)
-}