@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/plugin/install.ts

@@ -1,439 +0,0 @@
-import path from "path"
-import {
-  type ParseError as JsoncParseError,
-  applyEdits,
-  modify,
-  parse as parseJsonc,
-  printParseErrorCode,
-} from "jsonc-parser"
-
-import * as ConfigPaths from "@/config/paths"
-import { Global } from "@/global"
-import { Filesystem } from "@/util"
-import { Flock } from "@sleepy-ai/shared/util/flock"
-import { isRecord } from "@/util/record"
-
-import { parsePluginSpecifier, readPackageThemes, readPluginPackage, resolvePluginTarget } from "./shared"
-
-type Mode = "noop" | "add" | "replace"
-type Kind = "server" | "tui"
-
-export type Target = {
-  kind: Kind
-  opts?: Record<string, unknown>
-}
-
-export type InstallDeps = {
-  resolve: (spec: string) => Promise<string>
-}
-
-export type PatchDeps = {
-  readText: (file: string) => Promise<string>
-  write: (file: string, text: string) => Promise<void>
-  exists: (file: string) => Promise<boolean>
-  files: (dir: string, name: "sleepycode" | "tui") => string[]
-}
-
-export type PatchInput = {
-  spec: string
-  targets: Target[]
-  force?: boolean
-  global?: boolean
-  vcs?: string
-  worktree: string
-  directory: string
-  config?: string
-}
-
-type Ok<T> = {
-  ok: true
-} & T
-
-type Err<C extends string, T> = {
-  ok: false
-  code: C
-} & T
-
-export type InstallResult = Ok<{ target: string }> | Err<"install_failed", { error: unknown }>
-
-export type ManifestResult =
-  | Ok<{ targets: Target[] }>
-  | Err<"manifest_read_failed", { file: string; error: unknown }>
-  | Err<"manifest_no_targets", { file: string }>
-
-export type PatchItem = {
-  kind: Kind
-  mode: Mode
-  file: string
-}
-
-type PatchErr =
-  | Err<"invalid_json", { kind: Kind; file: string; line: number; col: number; parse: string }>
-  | Err<"patch_failed", { kind: Kind; error: unknown }>
-
-type PatchOne = Ok<{ item: PatchItem }> | PatchErr
-
-export type PatchResult = Ok<{ dir: string; items: PatchItem[] }> | (PatchErr & { dir: string })
-
-const defaultInstallDeps: InstallDeps = {
-  resolve: (spec) => resolvePluginTarget(spec),
-}
-
-const defaultPatchDeps: PatchDeps = {
-  readText: (file) => Filesystem.readText(file),
-  write: async (file, text) => {
-    await Filesystem.write(file, text)
-  },
-  exists: (file) => Filesystem.exists(file),
-  files: (dir, name) => ConfigPaths.fileInDirectory(dir, name),
-}
-
-function pluginSpec(item: unknown) {
-  if (typeof item === "string") return item
-  if (!Array.isArray(item)) return
-  if (typeof item[0] !== "string") return
-  return item[0]
-}
-
-function pluginList(data: unknown) {
-  if (!data || typeof data !== "object" || Array.isArray(data)) return
-  const item = data as { plugin?: unknown }
-  if (!Array.isArray(item.plugin)) return
-  return item.plugin
-}
-
-function exportValue(value: unknown): string | undefined {
-  if (typeof value === "string") {
-    const next = value.trim()
-    if (next) return next
-    return
-  }
-  if (!isRecord(value)) return
-  for (const key of ["import", "default"]) {
-    const next = value[key]
-    if (typeof next !== "string") continue
-    const hit = next.trim()
-    if (!hit) continue
-    return hit
-  }
-}
-
-function exportOptions(value: unknown): Record<string, unknown> | undefined {
-  if (!isRecord(value)) return
-  const config = value.config
-  if (!isRecord(config)) return
-  return config
-}
-
-function exportTarget(pkg: Record<string, unknown>, kind: Kind) {
-  const exports = pkg.exports
-  if (!isRecord(exports)) return
-  const value = exports[`./${kind}`]
-  const entry = exportValue(value)
-  if (!entry) return
-  return {
-    opts: exportOptions(value),
-  }
-}
-
-function hasMainTarget(pkg: Record<string, unknown>) {
-  const main = pkg.main
-  if (typeof main !== "string") return false
-  return Boolean(main.trim())
-}
-
-function packageTargets(pkg: { json: Record<string, unknown>; dir: string; pkg: string }) {
-  const spec =
-    typeof pkg.json.name === "string" && pkg.json.name.trim().length > 0 ? pkg.json.name.trim() : path.basename(pkg.dir)
-  const targets: Target[] = []
-  const server = exportTarget(pkg.json, "server")
-  if (server) {
-    targets.push({ kind: "server", opts: server.opts })
-  } else if (hasMainTarget(pkg.json)) {
-    targets.push({ kind: "server" })
-  }
-
-  const tui = exportTarget(pkg.json, "tui")
-  if (tui) {
-    targets.push({ kind: "tui", opts: tui.opts })
-  }
-
-  if (!targets.some((item) => item.kind === "tui") && readPackageThemes(spec, pkg).length) {
-    targets.push({ kind: "tui" })
-  }
-
-  return targets
-}
-
-function patch(text: string, path: Array<string | number>, value: unknown, insert = false) {
-  return applyEdits(
-    text,
-    modify(text, path, value, {
-      formattingOptions: {
-        tabSize: 2,
-        insertSpaces: true,
-      },
-      isArrayInsertion: insert,
-    }),
-  )
-}
-
-function patchPluginList(
-  text: string,
-  list: unknown[] | undefined,
-  spec: string,
-  next: unknown,
-  force = false,
-): { mode: Mode; text: string } {
-  const pkg = parsePluginSpecifier(spec).pkg
-  const rows = (list ?? []).map((item, i) => ({
-    item,
-    i,
-    spec: pluginSpec(item),
-  }))
-  const dup = rows.filter((item) => {
-    if (!item.spec) return false
-    if (item.spec === spec) return true
-    if (item.spec.startsWith("file://")) return false
-    return parsePluginSpecifier(item.spec).pkg === pkg
-  })
-
-  if (!dup.length) {
-    if (!list) {
-      return {
-        mode: "add",
-        text: patch(text, ["plugin"], [next]),
-      }
-    }
-    return {
-      mode: "add",
-      text: patch(text, ["plugin", list.length], next, true),
-    }
-  }
-
-  if (!force) {
-    return {
-      mode: "noop",
-      text,
-    }
-  }
-
-  const keep = dup[0]
-  if (!keep) {
-    return {
-      mode: "noop",
-      text,
-    }
-  }
-
-  if (dup.length === 1 && keep.spec === spec) {
-    return {
-      mode: "noop",
-      text,
-    }
-  }
-
-  let out = text
-  if (typeof keep.item === "string") {
-    out = patch(out, ["plugin", keep.i], next)
-  }
-  if (Array.isArray(keep.item) && typeof keep.item[0] === "string") {
-    out = patch(out, ["plugin", keep.i, 0], spec)
-  }
-
-  const del = dup
-    .map((item) => item.i)
-    .filter((i) => i !== keep.i)
-    .sort((a, b) => b - a)
-
-  for (const i of del) {
-    out = patch(out, ["plugin", i], undefined)
-  }
-
-  return {
-    mode: "replace",
-    text: out,
-  }
-}
-
-export async function installPlugin(spec: string, dep: InstallDeps = defaultInstallDeps): Promise<InstallResult> {
-  const target = await dep.resolve(spec).then(
-    (item) => ({
-      ok: true as const,
-      item,
-    }),
-    (error: unknown) => ({
-      ok: false as const,
-      error,
-    }),
-  )
-  if (!target.ok) {
-    return {
-      ok: false,
-      code: "install_failed",
-      error: target.error,
-    }
-  }
-  return {
-    ok: true,
-    target: target.item,
-  }
-}
-
-export async function readPluginManifest(target: string): Promise<ManifestResult> {
-  const pkg = await readPluginPackage(target).then(
-    (item) => ({
-      ok: true as const,
-      item,
-    }),
-    (error: unknown) => ({
-      ok: false as const,
-      error,
-    }),
-  )
-  if (!pkg.ok) {
-    return {
-      ok: false,
-      code: "manifest_read_failed",
-      file: target,
-      error: pkg.error,
-    }
-  }
-
-  const targets = await Promise.resolve()
-    .then(() => packageTargets(pkg.item))
-    .then(
-      (item) => ({ ok: true as const, item }),
-      (error: unknown) => ({ ok: false as const, error }),
-    )
-
-  if (!targets.ok) {
-    return {
-      ok: false,
-      code: "manifest_read_failed",
-      file: pkg.item.pkg,
-      error: targets.error,
-    }
-  }
-
-  if (!targets.item.length) {
-    return {
-      ok: false,
-      code: "manifest_no_targets",
-      file: pkg.item.pkg,
-    }
-  }
-
-  return {
-    ok: true,
-    targets: targets.item,
-  }
-}
-
-function patchDir(input: PatchInput) {
-  if (input.global) return input.config ?? Global.Path.config
-  const git = input.vcs === "git" && input.worktree !== "/"
-  const root = git ? input.worktree : input.directory
-  return path.join(root, ".sleepycode")
-}
-
-function patchName(kind: Kind): "sleepycode" | "tui" {
-  if (kind === "server") return "sleepycode"
-  return "tui"
-}
-
-async function patchOne(dir: string, target: Target, spec: string, force: boolean, dep: PatchDeps): Promise<PatchOne> {
-  const name = patchName(target.kind)
-  await using _ = await Flock.acquire(`plug-config:${Filesystem.resolve(path.join(dir, name))}`)
-
-  const files = dep.files(dir, name)
-  let cfg = files[0]
-  for (const file of files) {
-    if (!(await dep.exists(file))) continue
-    cfg = file
-    break
-  }
-
-  const src = await dep.readText(cfg).catch((err: NodeJS.ErrnoException) => {
-    if (err.code === "ENOENT") return "{}"
-    return err
-  })
-  if (src instanceof Error) {
-    return {
-      ok: false,
-      code: "patch_failed",
-      kind: target.kind,
-      error: src,
-    }
-  }
-  const text = src.trim() ? src : "{}"
-
-  const errs: JsoncParseError[] = []
-  const data = parseJsonc(text, errs, { allowTrailingComma: true })
-  if (errs.length) {
-    const err = errs[0]
-    const lines = text.substring(0, err.offset).split("\n")
-    return {
-      ok: false,
-      code: "invalid_json",
-      kind: target.kind,
-      file: cfg,
-      line: lines.length,
-      col: lines[lines.length - 1].length + 1,
-      parse: printParseErrorCode(err.error),
-    }
-  }
-
-  const list = pluginList(data)
-  const item = target.opts ? ([spec, target.opts] as const) : spec
-  const out = patchPluginList(text, list, spec, item, force)
-  if (out.mode === "noop") {
-    return {
-      ok: true,
-      item: {
-        kind: target.kind,
-        mode: out.mode,
-        file: cfg,
-      },
-    }
-  }
-
-  const write = await dep.write(cfg, out.text).catch((error: unknown) => error)
-  if (write instanceof Error) {
-    return {
-      ok: false,
-      code: "patch_failed",
-      kind: target.kind,
-      error: write,
-    }
-  }
-
-  return {
-    ok: true,
-    item: {
-      kind: target.kind,
-      mode: out.mode,
-      file: cfg,
-    },
-  }
-}
-
-export async function patchPluginConfig(input: PatchInput, dep: PatchDeps = defaultPatchDeps): Promise<PatchResult> {
-  const dir = patchDir(input)
-  const items: PatchItem[] = []
-  for (const target of input.targets) {
-    const hit = await patchOne(dir, target, input.spec, Boolean(input.force), dep)
-    if (!hit.ok) {
-      return {
-        ...hit,
-        dir,
-      }
-    }
-    items.push(hit.item)
-  }
-  return {
-    ok: true,
-    dir,
-    items,
-  }
-}

package/src/plugin/loader.ts

@@ -1,216 +0,0 @@
-import {
-  checkPluginCompatibility,
-  createPluginEntry,
-  isDeprecatedPlugin,
-  pluginSource,
-  resolvePluginTarget,
-  type PluginKind,
-  type PluginPackage,
-  type PluginSource,
-} from "./shared"
-import { ConfigPlugin } from "@/config/plugin"
-import { InstallationVersion } from "@/installation/version"
-
-export namespace PluginLoader {
-  // A normalized plugin declaration derived from config before any filesystem or npm work happens.
-  export type Plan = {
-    spec: string
-    options: ConfigPlugin.Options | undefined
-    deprecated: boolean
-  }
-
-  // A plugin that has been resolved to a concrete target and entrypoint on disk.
-  export type Resolved = Plan & {
-    source: PluginSource
-    target: string
-    entry: string
-    pkg?: PluginPackage
-  }
-
-  // A plugin target we could inspect, but which does not expose the requested kind of entrypoint.
-  export type Missing = Plan & {
-    source: PluginSource
-    target: string
-    pkg?: PluginPackage
-    message: string
-  }
-
-  // A resolved plugin whose module has been imported successfully.
-  export type Loaded = Resolved & {
-    mod: Record<string, unknown>
-  }
-
-  type Candidate = { origin: ConfigPlugin.Origin; plan: Plan }
-  type Report = {
-    // Called before each attempt so callers can log initial load attempts and retries uniformly.
-    start?: (candidate: Candidate, retry: boolean) => void
-    // Called when the package exists but does not provide the requested entrypoint.
-    missing?: (candidate: Candidate, retry: boolean, message: string, resolved: Missing) => void
-    // Called for operational failures such as install, compatibility, or dynamic import errors.
-    error?: (
-      candidate: Candidate,
-      retry: boolean,
-      stage: "install" | "entry" | "compatibility" | "load",
-      error: unknown,
-      resolved?: Resolved,
-    ) => void
-  }
-
-  // Normalize a config item into the loader's internal representation.
-  function plan(item: ConfigPlugin.Spec): Plan {
-    const spec = ConfigPlugin.pluginSpecifier(item)
-    return { spec, options: ConfigPlugin.pluginOptions(item), deprecated: isDeprecatedPlugin(spec) }
-  }
-
-  // Resolve a configured plugin into a concrete entrypoint that can later be imported.
-  //
-  // The stages here intentionally separate install/target resolution, entrypoint detection,
-  // and compatibility checks so callers can report the exact reason a plugin was skipped.
-  export async function resolve(
-    plan: Plan,
-    kind: PluginKind,
-  ): Promise<
-    | { ok: true; value: Resolved }
-    | { ok: false; stage: "missing"; value: Missing }
-    | { ok: false; stage: "install" | "entry" | "compatibility"; error: unknown }
-  > {
-    // First make sure the plugin exists locally, installing npm plugins on demand.
-    let target = ""
-    try {
-      target = await resolvePluginTarget(plan.spec)
-    } catch (error) {
-      return { ok: false, stage: "install", error }
-    }
-    if (!target) return { ok: false, stage: "install", error: new Error(`Plugin ${plan.spec} target is empty`) }
-
-    // Then inspect the target for the requested server/tui entrypoint.
-    let base
-    try {
-      base = await createPluginEntry(plan.spec, target, kind)
-    } catch (error) {
-      return { ok: false, stage: "entry", error }
-    }
-    if (!base.entry)
-      return {
-        ok: false,
-        stage: "missing",
-        value: {
-          ...plan,
-          source: base.source,
-          target: base.target,
-          pkg: base.pkg,
-          message: `Plugin ${plan.spec} does not expose a ${kind} entrypoint`,
-        },
-      }
-
-    // npm plugins can declare which opencode versions they support; file plugins are treated
-    // as local development code and skip this compatibility gate.
-    if (base.source === "npm") {
-      try {
-        await checkPluginCompatibility(base.target, InstallationVersion, base.pkg)
-      } catch (error) {
-        return { ok: false, stage: "compatibility", error }
-      }
-    }
-    return { ok: true, value: { ...plan, source: base.source, target: base.target, entry: base.entry, pkg: base.pkg } }
-  }
-
-  // Import the resolved module only after all earlier validation has succeeded.
-  export async function load(row: Resolved): Promise<{ ok: true; value: Loaded } | { ok: false; error: unknown }> {
-    let mod
-    try {
-      mod = await import(row.entry)
-    } catch (error) {
-      return { ok: false, error }
-    }
-    if (!mod) return { ok: false, error: new Error(`Plugin ${row.spec} module is empty`) }
-    return { ok: true, value: { ...row, mod } }
-  }
-
-  // Run one candidate through the full pipeline: resolve, optionally surface a missing entry,
-  // import the module, and finally let the caller transform the loaded plugin into any result type.
-  async function attempt<R>(
-    candidate: Candidate,
-    kind: PluginKind,
-    retry: boolean,
-    finish: ((load: Loaded, origin: ConfigPlugin.Origin, retry: boolean) => Promise<R | undefined>) | undefined,
-    missing: ((value: Missing, origin: ConfigPlugin.Origin, retry: boolean) => Promise<R | undefined>) | undefined,
-    report: Report | undefined,
-  ): Promise<R | undefined> {
-    const plan = candidate.plan
-
-    // Deprecated plugin packages are silently ignored because they are now built in.
-    if (plan.deprecated) return
-
-    report?.start?.(candidate, retry)
-
-    const resolved = await resolve(plan, kind)
-    if (!resolved.ok) {
-      if (resolved.stage === "missing") {
-        // Missing entrypoints are handled separately so callers can still inspect package metadata,
-        // for example to load theme files from a tui plugin package that has no code entrypoint.
-        if (missing) {
-          const value = await missing(resolved.value, candidate.origin, retry)
-          if (value !== undefined) return value
-        }
-        report?.missing?.(candidate, retry, resolved.value.message, resolved.value)
-        return
-      }
-      report?.error?.(candidate, retry, resolved.stage, resolved.error)
-      return
-    }
-
-    const loaded = await load(resolved.value)
-    if (!loaded.ok) {
-      report?.error?.(candidate, retry, "load", loaded.error, resolved.value)
-      return
-    }
-
-    // The default behavior is to return the successfully loaded plugin as-is, but callers can
-    // provide a finisher to adapt the result into a more specific runtime shape.
-    if (!finish) return loaded.value as R
-    return finish(loaded.value, candidate.origin, retry)
-  }
-
-  type Input<R> = {
-    items: ConfigPlugin.Origin[]
-    kind: PluginKind
-    wait?: () => Promise<void>
-    finish?: (load: Loaded, origin: ConfigPlugin.Origin, retry: boolean) => Promise<R | undefined>
-    missing?: (value: Missing, origin: ConfigPlugin.Origin, retry: boolean) => Promise<R | undefined>
-    report?: Report
-  }
-
-  // Resolve and load all configured plugins in parallel.
-  //
-  // If `wait` is provided, file-based plugins that initially failed are retried once after the
-  // caller finishes preparing dependencies. This supports local plugins that depend on an install
-  // step happening elsewhere before their entrypoint becomes loadable.
-  export async function loadExternal<R = Loaded>(input: Input<R>): Promise<R[]> {
-    const candidates = input.items.map((origin) => ({ origin, plan: plan(origin.spec) }))
-    const list: Array<Promise<R | undefined>> = []
-    for (const candidate of candidates) {
-      list.push(attempt(candidate, input.kind, false, input.finish, input.missing, input.report))
-    }
-    const out = await Promise.all(list)
-    if (input.wait) {
-      let deps: Promise<void> | undefined
-      for (let i = 0; i < candidates.length; i++) {
-        if (out[i] !== undefined) continue
-
-        // Only local file plugins are retried. npm plugins already attempted installation during
-        // the first pass, while file plugins may need the caller's dependency preparation to finish.
-        const candidate = candidates[i]
-        if (!candidate || pluginSource(candidate.plan.spec) !== "file") continue
-        deps ??= input.wait()
-        await deps
-        out[i] = await attempt(candidate, input.kind, true, input.finish, input.missing, input.report)
-      }
-    }
-
-    // Drop skipped/failed entries while preserving the successful result order.
-    const ready: R[] = []
-    for (const item of out) if (item !== undefined) ready.push(item)
-    return ready
-  }
-}

package/src/plugin/matcher.ts

@@ -1,33 +0,0 @@
-import { BUILT_IN_AGENTS, type ActorMatcher } from "@sleepy-ai/plugin"
-
-const isBuiltIn = (agentType: string): boolean =>
-  (BUILT_IN_AGENTS as readonly string[]).includes(agentType)
-
-export function matchesActor(
-  matcher: ActorMatcher | undefined,
-  input: { mode: "subagent" | "peer"; agentType: string },
-): boolean {
-  if (!matcher) return !isBuiltIn(input.agentType)
-
-  if (matcher.mode && matcher.mode !== input.mode) return false
-
-  const at = matcher.agentType
-
-  if (at === undefined) return !isBuiltIn(input.agentType)
-
-  if (typeof at === "string") {
-    if (isBuiltIn(input.agentType)) return false
-    try {
-      return new RegExp(at).test(input.agentType)
-    } catch {
-      return false
-    }
-  }
-
-  if (Array.isArray(at)) return at.includes(input.agentType)
-
-  if ("excludeOnly" in at) return !at.excludeOnly.includes(input.agentType)
-
-  if (at.exclude?.includes(input.agentType)) return false
-  return at.include.includes(input.agentType)
-}