@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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)
-}

package/src/shared/startup-diagnostics.ts

@@ -1,77 +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 { 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
-
-    console.warn(`[hiai-opencode] WARNING: ${configPath} contains plugin: ["list"].`)
-    console.warn("[hiai-opencode] This can prevent hiai-opencode MCP servers from loading from that config scope.")
-    console.warn(`[hiai-opencode] 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
-
-    console.warn(
-      `[hiai-opencode] 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
-}