saeeol 1.4.2 → 1.4.3

package/src/overlay/mcp-migrator.ts

@@ -1,181 +0,0 @@
-import * as fs from "fs/promises"
-import * as path from "path"
-import { Config } from "../config/config"
-import { ConfigMCP } from "../config/mcp"
-import * as Log from "@saeeol/core/util/log"
-import { Filesystem } from "../util/filesystem"
-import { SaeeolPaths } from "./paths"
-
-export namespace McpMigrator {
-  const log = Log.create({ service: "saeeol.mcp-migrator" })
-
-  // Remote transport types used by the Saeeol extension
-  const REMOTE_TYPES = new Set(["streamable-http", "sse"])
-
-  function isRemote(server: SaeeolMcpServer): boolean {
-    return !!server.type && REMOTE_TYPES.has(server.type)
-  }
-
-  // Saeeol MCP server structure
-  export interface SaeeolMcpServer {
-    command?: string
-    args?: string[]
-    env?: Record<string, string>
-    disabled?: boolean
-    alwaysAllow?: string[]
-    // Remote server fields
-    type?: string
-    url?: string
-    headers?: Record<string, string>
-  }
-
-  export interface SaeeolMcpSettings {
-    mcpServers: Record<string, SaeeolMcpServer>
-  }
-
-  export interface MigrationResult {
-    mcp: Record<string, ConfigMCP.Info>
-    warnings: string[]
-    skipped: Array<{ name: string; reason: string }>
-  }
-
-  export async function readMcpSettings(filepath: string): Promise<SaeeolMcpSettings | null> {
-    if (!(await Filesystem.exists(filepath))) return null
-
-    try {
-      const content = await fs.readFile(filepath, "utf-8")
-      return JSON.parse(content) as SaeeolMcpSettings
-    } catch (err) {
-      log.warn("failed to parse MCP settings file, skipping", { filepath, error: err })
-      return null
-    }
-  }
-
-  export function convertServer(name: string, server: SaeeolMcpServer): ConfigMCP.Info | null {
-    if (isRemote(server)) {
-      if (!server.url) {
-        log.warn("remote MCP server missing url, skipping", { name })
-        return null
-      }
-      const config: ConfigMCP.Info = {
-        type: "remote",
-        url: server.url,
-        ...(server.headers && Object.keys(server.headers).length > 0 && { headers: server.headers }),
-        ...(server.disabled && { enabled: false }),
-      }
-      return config
-    }
-
-    if (!server.command) {
-      log.warn("local MCP server missing command, skipping", { name })
-      return null
-    }
-
-    // Build command array: [command, ...args]
-    const command = [server.command, ...(server.args ?? [])]
-
-    // Build the MCP config object
-    const config: ConfigMCP.Info = {
-      type: "local",
-      command,
-      ...(server.env && Object.keys(server.env).length > 0 && { environment: server.env }),
-      ...(server.disabled && { enabled: false }),
-    }
-
-    return config
-  }
-
-  export async function migrate(options?: {
-    projectDir?: string
-    skipGlobalPaths?: boolean
-  }): Promise<MigrationResult> {
-    const warnings: string[] = []
-    const skipped: Array<{ name: string; reason: string }> = []
-    const mcp: Record<string, ConfigMCP.Info> = {}
-
-    const allServers: Array<{ name: string; server: SaeeolMcpServer }> = []
-
-    if (!options?.skipGlobalPaths) {
-      // 1. VSCode extension global storage (primary location for global MCP settings)
-      const vscodeSettingsPath = path.join(SaeeolPaths.vscodeGlobalStorage(), "settings", "mcp_settings.json")
-      const vscodeSettings = await readMcpSettings(vscodeSettingsPath)
-      if (vscodeSettings?.mcpServers) {
-        for (const [name, server] of Object.entries(vscodeSettings.mcpServers)) {
-          allServers.push({ name, server })
-        }
-      }
-    }
-
-    // 2. Project-level MCP settings (if projectDir provided)
-    // Check .saeeol/mcp.json and .saeeol/mcp.json for project-level settings
-    // .saeeol is loaded (project-level settings)
-    // (not "mcp_settings.json" which is only used for global settings)
-    if (options?.projectDir) {
-      for (const dir of [".saeeol"]) {
-        const projectSettingsPath = path.join(options.projectDir, dir, "mcp.json")
-        const projectSettings = await readMcpSettings(projectSettingsPath)
-        if (projectSettings?.mcpServers) {
-          for (const [name, server] of Object.entries(projectSettings.mcpServers)) {
-            allServers.push({ name, server }) // Later entries win in deduplication
-          }
-        }
-      }
-    }
-
-    // Deduplicate by name (later entries win - project overrides global)
-    const serversByName = new Map<string, SaeeolMcpServer>()
-    for (const { name, server } of allServers) {
-      serversByName.set(name, server)
-    }
-
-    // Convert each server
-    for (const [name, server] of serversByName) {
-      // Warn about alwaysAllow permissions that cannot be migrated
-      if (server.alwaysAllow && server.alwaysAllow.length > 0) {
-        warnings.push(
-          `MCP server '${name}' has alwaysAllow permissions that cannot be migrated: ${server.alwaysAllow.join(", ")}`,
-        )
-      }
-
-      const converted = convertServer(name, server)
-      if (converted) {
-        mcp[name] = converted
-      }
-    }
-
-    return { mcp, warnings, skipped }
-  }
-
-  /**
-   * Load Saeeol MCP servers and return them as an saeeol config partial.
-   * This function handles all logging internally, so callers just need to merge the result.
-   */
-  export async function loadMcpConfig(
-    projectDir: string,
-    skipGlobalPaths?: boolean,
-  ): Promise<Record<string, ConfigMCP.Info>> {
-    try {
-      const result = await migrate({ projectDir, skipGlobalPaths })
-
-      if (Object.keys(result.mcp).length > 0) {
-        log.debug("loaded saeeol MCP servers", {
-          count: Object.keys(result.mcp).length,
-          servers: Object.keys(result.mcp),
-        })
-      }
-
-      for (const skipped of result.skipped) {
-        log.debug("skipped saeeol MCP server", { name: skipped.name, reason: skipped.reason })
-      }
-
-      for (const warning of result.warnings) {
-        log.warn("saeeol MCP migration warning", { warning })
-      }
-
-      return result.mcp
-    } catch (err) {
-      log.warn("failed to load saeeol MCP servers", { error: err })
-      return {}
-    }
-  }
-}

package/src/overlay/mcp-oauth-callback.ts

@@ -1,93 +0,0 @@
-import type { Server } from "http"
-
-const host = "127.0.0.1"
-
-type State = {
-  server: Server | undefined
-  port: number
-  path: string
-}
-
-type Deps = {
-  redirectUri?: string
-  parse: (uri?: string) => { port: number; path: string }
-  state: () => State
-  set: (state: State) => void
-  create: () => Server
-  stop: () => Promise<void>
-  info: (msg: string, data?: Record<string, unknown>) => void
-  error: (msg: string, data?: Record<string, unknown>) => void
-}
-
-let active = host
-let start: Promise<void> | null = null
-
-export function parseHost(uri?: string): string {
-  if (!uri) return host
-  try {
-    return new URL(uri).hostname || host
-  } catch {
-    return host
-  }
-}
-
-export function listen(srv: Server, host: string, port: number): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const fail = (err: Error & { code?: string }) => {
-      srv.off("error", fail)
-      if (err.code === "EADDRINUSE") {
-        reject(
-          new Error(
-            `OAuth callback port ${port} is already in use. Close the other Saeeol process or configure a different MCP OAuth redirect URI, then retry.`,
-          ),
-        )
-        return
-      }
-      reject(err)
-    }
-
-    srv.once("error", fail)
-    srv.listen(port, host, () => {
-      srv.off("error", fail)
-      resolve()
-    })
-  })
-}
-
-export async function ensureRunning(deps: Deps): Promise<void> {
-  const cfg = deps.parse(deps.redirectUri)
-  const nextHost = parseHost(deps.redirectUri)
-
-  if (start) await start
-
-  const state = deps.state()
-  if (state.server && (active !== nextHost || state.port !== cfg.port || state.path !== cfg.path)) {
-    deps.info("stopping oauth callback server to reconfigure", {
-      oldHost: active,
-      oldPort: state.port,
-      newHost: nextHost,
-      newPort: cfg.port,
-    })
-    await deps.stop()
-  }
-
-  if (deps.state().server) return
-
-  active = nextHost
-  const srv = deps.create()
-  start = listen(srv, active, cfg.port).then(() => {
-    deps.set({ server: srv, port: cfg.port, path: cfg.path })
-    deps.info("oauth callback server started", { host: active, port: cfg.port, path: cfg.path })
-  })
-
-  try {
-    await start
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("already in use")) {
-      deps.error("oauth callback bind failed: port already in use", { host: active, port: cfg.port, path: cfg.path })
-    }
-    throw err
-  } finally {
-    start = null
-  }
-}

package/src/overlay/memory/age.ts

@@ -1 +0,0 @@
-export { memoryAgeDays, memoryAge, memoryFreshnessText } from "@/boxes/memory"

package/src/overlay/memory/index.ts

@@ -1,37 +0,0 @@
-/**
- * Memory system — re-exported from @saeeol/boxes
- * Original 5-file module (types + age + paths + scan + index) → single atom
- */
-export {
-  MEMORY_TYPES,
-  parseMemoryType,
-  memoryAgeDays,
-  memoryAge,
-  memoryFreshnessText,
-  getMemoryBaseDir,
-  getMemoryDir,
-  getMemoryEntrypoint,
-  isMemoryPath,
-  scanMemoryFiles,
-  formatMemoryManifest,
-  truncateEntrypoint,
-  readEntrypoint,
-  writeEntrypoint,
-  ensureDir,
-  buildPrompt,
-  scan,
-} from "@/boxes/memory"
-export type { MemoryType, MemoryHeader } from "@/boxes/memory"
-
-// Namespace wrapper for backward compatibility
-import * as Mem from "@/boxes/memory"
-export const Memory = {
-  scan: Mem.scan,
-  buildPrompt: Mem.buildPrompt,
-  readEntrypoint: Mem.readEntrypoint,
-  writeEntrypoint: Mem.writeEntrypoint,
-  ensureDir: Mem.ensureDir,
-  scanMemoryFiles: Mem.scanMemoryFiles,
-  formatMemoryManifest: Mem.formatMemoryManifest,
-  truncateEntrypoint: Mem.truncateEntrypoint,
-}

package/src/overlay/memory/paths.ts

@@ -1,4 +0,0 @@
-export {
-  getMemoryBaseDir, getMemoryDir, getMemoryEntrypoint, isMemoryPath,
-  MAX_ENTRYPOINT_LINES, MAX_ENTRYPOINT_BYTES,
-} from "@/boxes/memory"

package/src/overlay/memory/scan.ts

@@ -1 +0,0 @@
-export { scanMemoryFiles, formatMemoryManifest } from "@/boxes/memory"

package/src/overlay/memory/types.ts

@@ -1,2 +0,0 @@
-export { MEMORY_TYPES, parseMemoryType } from "@/boxes/memory"
-export type { MemoryType } from "@/boxes/memory"

package/src/overlay/model-match.ts

@@ -1,6 +0,0 @@
-const LING_EXCLUDES = ["kling", "bling", "spelling", "multilingual"]
-
-export function isLing(id: string) {
-  const lower = id.toLowerCase()
-  return lower.includes("ling") && !LING_EXCLUDES.some((s) => lower.includes(s))
-}

package/src/overlay/modes-migrator.ts

@@ -1,211 +0,0 @@
-import matter from "gray-matter"
-import * as fs from "fs/promises"
-import * as path from "path"
-import os from "os"
-import { Config } from "../config/config"
-import { ConfigAgent } from "../config/agent"
-import { ConfigPermission } from "../config/permission"
-import { SaeeolPaths } from "./paths"
-import type { OrganizationMode } from "@saeeol/gateway"
-
-export namespace ModesMigrator {
-  // Saeeol mode structure
-  export interface SaeeolMode {
-    slug: string
-    name: string
-    roleDefinition: string
-    groups: Array<string | [string, { fileRegex?: string; description?: string }]>
-    customInstructions?: string
-    whenToUse?: string
-    description?: string
-    source?: "global" | "project" | "organization"
-  }
-
-  export interface SaeeolModesFile {
-    customModes: SaeeolMode[]
-  }
-
-  // Default modes to skip - these have native Saeeol equivalents
-  const DEFAULT_MODE_SLUGS = new Set(["code", "build", "architect", "ask", "debug", "orchestrator"])
-
-  // Group to permission mapping
-  const GROUP_TO_PERMISSION: Record<string, string> = {
-    read: "read",
-    edit: "edit",
-    browser: "bash",
-    command: "bash",
-    mcp: "mcp",
-  }
-
-  // All permissions that should be explicitly set (deny if not in groups)
-  const ALL_PERMISSIONS = ["read", "edit", "bash", "mcp"]
-
-  export function isDefaultMode(slug: string): boolean {
-    return DEFAULT_MODE_SLUGS.has(slug)
-  }
-
-  export function convertPermissions(groups: SaeeolMode["groups"]): ConfigPermission.Info {
-    const permission: Record<string, any> = {}
-    const allowedPermissions = new Set<string>()
-
-    for (const group of groups) {
-      if (typeof group === "string") {
-        const permKey = GROUP_TO_PERMISSION[group] ?? group
-        allowedPermissions.add(permKey)
-        permission[permKey] = "allow"
-      } else if (Array.isArray(group)) {
-        const [groupName, config] = group
-        const permKey = GROUP_TO_PERMISSION[groupName] ?? groupName
-        allowedPermissions.add(permKey)
-
-        if (config?.fileRegex) {
-          permission[permKey] = {
-            [config.fileRegex]: "allow",
-            "*": "deny",
-          }
-        } else {
-          permission[permKey] = "allow"
-        }
-      }
-    }
-
-    // Explicitly deny permissions that aren't in the groups
-    // This is critical because Saeeol defaults to "ask" for missing permissions
-    for (const perm of ALL_PERMISSIONS) {
-      if (!allowedPermissions.has(perm)) {
-        permission[perm] = "deny"
-      }
-    }
-
-    return permission
-  }
-
-  export function convertMode(mode: SaeeolMode): ConfigAgent.Info {
-    const prompt = [mode.roleDefinition, mode.customInstructions].filter(Boolean).join("\n\n")
-
-    return {
-      mode: "primary",
-      description: mode.description ?? mode.whenToUse ?? mode.name,
-      prompt,
-      permission: convertPermissions(mode.groups),
-    }
-  }
-
-  /**
-   * Convert a cloud OrganizationMode to a ConfigAgent.Info.
-   * Unlike legacy convertMode(), this does NOT skip default slugs —
-   * organization admins can intentionally override built-in agents.
-   */
-  export function convertOrganizationMode(mode: OrganizationMode): ConfigAgent.Info {
-    const cfg = mode.config
-    const prompt = [cfg.roleDefinition, cfg.customInstructions].filter(Boolean).join("\n\n")
-    const groups = cfg.groups ?? []
-    if (groups.length === 0) {
-      console.warn(
-        `[ModesMigrator] Organization mode "${mode.slug}" has no groups configured — all tool permissions will be denied`,
-      )
-    }
-
-    return {
-      mode: "primary",
-      description: cfg.description ?? cfg.whenToUse ?? mode.name,
-      prompt: prompt || undefined,
-      permission: convertPermissions(groups),
-      options: { source: "organization", displayName: mode.name },
-    }
-  }
-
-  /**
-   * Convert an array of cloud OrganizationModes to a ConfigAgent.Info record
-   * keyed by slug. All modes are included (no default-slug filtering).
-   */
-  export function convertOrganizationModes(modes: OrganizationMode[]): Record<string, ConfigAgent.Info> {
-    const result: Record<string, ConfigAgent.Info> = {}
-    for (const mode of modes) {
-      result[mode.slug] = convertOrganizationMode(mode)
-    }
-    return result
-  }
-
-  export async function readModesFile(filepath: string): Promise<SaeeolMode[]> {
-    try {
-      const content = await fs.readFile(filepath, "utf-8")
-      // Wrap YAML content in frontmatter delimiters so gray-matter can parse it
-      const wrapped = `---\n${content}\n---`
-      const parsed = matter(wrapped).data as SaeeolModesFile
-      return parsed?.customModes ?? []
-    } catch (err: any) {
-      if (err.code === "ENOENT") return []
-      throw err
-    }
-  }
-
-  export interface MigrationResult {
-    agents: Record<string, ConfigAgent.Info>
-    skipped: Array<{ slug: string; reason: string }>
-  }
-
-  export async function migrate(options: {
-    projectDir: string
-    globalSettingsDir?: string
-    /** Skip reading from global paths (VSCode storage, home dir). Used for testing. */
-    skipGlobalPaths?: boolean
-  }): Promise<MigrationResult> {
-    const result: MigrationResult = {
-      agents: {},
-      skipped: [],
-    }
-
-    // Collect modes from all sources
-    const allModes: SaeeolMode[] = []
-
-    if (!options.skipGlobalPaths) {
-      // 1. VSCode extension global storage (primary location for global modes)
-      const vscodeGlobalPath = path.join(SaeeolPaths.vscodeGlobalStorage(), "settings", "custom_modes.yaml")
-      allModes.push(...(await readModesFile(vscodeGlobalPath)))
-
-      // 2. CLI global settings (fallback/alternative location)
-      const cliGlobalPath = path.join(os.homedir(), ".saeeol", "cli", "global", "settings", "custom_modes.yaml")
-      allModes.push(...(await readModesFile(cliGlobalPath)))
-
-      // 3. Home directory .saeeolmodes
-      const homeModesPath = path.join(os.homedir(), ".saeeolmodes")
-      if (homeModesPath !== options.projectDir) {
-        allModes.push(...(await readModesFile(homeModesPath)))
-      }
-    }
-
-    // 4. Legacy/explicit global settings dir (for backwards compatibility and testing)
-    if (options.globalSettingsDir) {
-      const legacyPath = path.join(options.globalSettingsDir, "custom_modes.yaml")
-      allModes.push(...(await readModesFile(legacyPath)))
-    }
-
-    // 5. Project .saeeolmodes
-    const projectModesPath = path.join(options.projectDir, ".saeeolmodes")
-    allModes.push(...(await readModesFile(projectModesPath)))
-
-    // Deduplicate by slug (later entries win)
-    const modesBySlug = new Map<string, SaeeolMode>()
-    for (const mode of allModes) {
-      modesBySlug.set(mode.slug, mode)
-    }
-
-    // Process each mode
-    for (const [slug, mode] of modesBySlug) {
-      // Skip default modes - let Saeeol's native agents handle these
-      if (isDefaultMode(slug)) {
-        result.skipped.push({
-          slug,
-          reason: "Default mode - using Saeeol native agent instead",
-        })
-        continue
-      }
-
-      // Migrate custom mode
-      result.agents[slug] = convertMode(mode)
-    }
-
-    return result
-  }
-}

package/src/overlay/paths.ts

@@ -1,94 +0,0 @@
-import * as path from "path"
-import os from "os"
-import { Filesystem } from "../util/filesystem"
-
-export namespace SaeeolPaths {
-  const home = () => process.env.HOME || process.env.USERPROFILE || os.homedir()
-
-  /**
-   * Get the platform-specific VSCode global storage path for Saeeol extension.
-   * - macOS: ~/Library/Application Support/Code/User/globalStorage/saeeol.saeeol
-   * - Windows: %APPDATA%/Code/User/globalStorage/saeeol.saeeol
-   * - Linux: ~/.config/Code/User/globalStorage/saeeol.saeeol
-   */
-  export function vscodeGlobalStorage(): string {
-    const home = os.homedir()
-    switch (process.platform) {
-      case "darwin":
-        return path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "saeeol.saeeol")
-      case "win32":
-        return path.join(
-          process.env.APPDATA || path.join(home, "AppData", "Roaming"),
-          "Code",
-          "User",
-          "globalStorage",
-          "saeeol.saeeol",
-        )
-      default:
-        return path.join(home, ".config", "Code", "User", "globalStorage", "saeeol.saeeol")
-    }
-  }
-
-  /** Global Saeeol directories in user home: ~/.saeeol */
-  export function globalDirs(): string[] {
-    return [path.join(home(), ".saeeol")]
-  }
-
-  /**
-   * Discover Saeeol directories containing skills.
-   * Returns parent directories (.saeeol/ and .saeeol/) for glob pattern "skills/[*]/SKILL.md".
-   *
-   * - Walks up from projectDir to worktreeRoot for .saeeol/ and .saeeol/
-   * - Includes global ~/.saeeol/ and ~/.saeeol/
-   * - Includes VSCode extension global storage
-   *
-   * Does NOT copy/migrate skills - just provides paths for discovery.
-   * Skills remain in their original locations and can be managed independently
-   * by the Saeeol VSCode extension.
-   */
-  export async function skillDirectories(opts: {
-    projectDir: string
-    worktreeRoot: string
-    skipGlobalPaths?: boolean
-  }): Promise<string[]> {
-    const directories: string[] = []
-
-    if (!opts.skipGlobalPaths) {
-      // 1. Global ~/.saeeol/ and ~/.saeeol/ (loaded first so project-level overrides)
-      for (const global of globalDirs()) {
-        const globalSkills = path.join(global, "skills")
-        if (!(await Filesystem.isDir(globalSkills))) continue
-        directories.push(global) // Return parent, not skills/
-      }
-
-      // 2. VSCode extension global storage (marketplace-installed skills)
-      const vscode = vscodeGlobalStorage()
-      const vscodeSkills = path.join(vscode, "skills")
-      if (await Filesystem.isDir(vscodeSkills)) {
-        directories.push(vscode) // Return parent, not skills/
-      }
-    }
-
-    // 3. Walk up from project dir to worktree root for .saeeol/ and .saeeol/
-    // Returns parent directories (not skills/) because
-    // the glob pattern "skills/[*]/SKILL.md" is applied from the parent
-    // Loaded last so project-level skills take precedence over global
-    for (const target of [".saeeol"] as const) {
-      const projectDirs = await Array.fromAsync(
-        Filesystem.up({
-          targets: [target],
-          start: opts.projectDir,
-          stop: opts.worktreeRoot,
-        }),
-      )
-      for (const dir of projectDirs) {
-        const skillsDir = path.join(dir, "skills")
-        if ((await Filesystem.isDir(skillsDir)) && !directories.includes(dir)) {
-          directories.push(dir)
-        }
-      }
-    }
-
-    return directories
-  }
-}