@vikasitai/vikasit-code 2.0.6 → 2.0.8

package/src/plugin/meta.ts

@@ -1,188 +0,0 @@
-import path from "path"
-import { fileURLToPath } from "url"
-
-import { Flag } from "@/flag/flag"
-import { Global } from "@/global"
-import { Filesystem } from "@/util/filesystem"
-import { Flock } from "@/util/flock"
-
-import { parsePluginSpecifier, pluginSource } from "./shared"
-
-export namespace PluginMeta {
-  type Source = "file" | "npm"
-
-  export type Theme = {
-    src: string
-    dest: string
-    mtime?: number
-    size?: number
-  }
-
-  export type Entry = {
-    id: string
-    source: Source
-    spec: string
-    target: string
-    requested?: string
-    version?: string
-    modified?: number
-    first_time: number
-    last_time: number
-    time_changed: number
-    load_count: number
-    fingerprint: string
-    themes?: Record<string, Theme>
-  }
-
-  export type State = "first" | "updated" | "same"
-
-  export type Touch = {
-    spec: string
-    target: string
-    id: string
-  }
-
-  type Store = Record<string, Entry>
-  type Core = Omit<Entry, "first_time" | "last_time" | "time_changed" | "load_count" | "fingerprint" | "themes">
-  type Row = Touch & { core: Core }
-
-  function storePath() {
-    return Flag.VIKASIT_PLUGIN_META_FILE ?? path.join(Global.Path.state, "plugin-meta.json")
-  }
-
-  function lock(file: string) {
-    return `plugin-meta:${file}`
-  }
-
-  function fileTarget(spec: string, target: string) {
-    if (spec.startsWith("file://")) return fileURLToPath(spec)
-    if (target.startsWith("file://")) return fileURLToPath(target)
-    return
-  }
-
-  async function modifiedAt(file: string) {
-    const stat = await Filesystem.statAsync(file)
-    if (!stat) return
-    const mtime = stat.mtimeMs
-    return Math.floor(typeof mtime === "bigint" ? Number(mtime) : mtime)
-  }
-
-  function resolvedTarget(target: string) {
-    if (target.startsWith("file://")) return fileURLToPath(target)
-    return target
-  }
-
-  async function npmVersion(target: string) {
-    const resolved = resolvedTarget(target)
-    const stat = await Filesystem.statAsync(resolved)
-    const dir = stat?.isDirectory() ? resolved : path.dirname(resolved)
-    return Filesystem.readJson<{ version?: string }>(path.join(dir, "package.json"))
-      .then((item) => item.version)
-      .catch(() => undefined)
-  }
-
-  async function entryCore(item: Touch): Promise<Core> {
-    const spec = item.spec
-    const target = item.target
-    const source = pluginSource(spec)
-    if (source === "file") {
-      const file = fileTarget(spec, target)
-      return {
-        id: item.id,
-        source,
-        spec,
-        target,
-        modified: file ? await modifiedAt(file) : undefined,
-      }
-    }
-
-    return {
-      id: item.id,
-      source,
-      spec,
-      target,
-      requested: parsePluginSpecifier(spec).version,
-      version: await npmVersion(target),
-    }
-  }
-
-  function fingerprint(value: Core) {
-    if (value.source === "file") return [value.target, value.modified ?? ""].join("|")
-    return [value.target, value.requested ?? "", value.version ?? ""].join("|")
-  }
-
-  async function read(file: string): Promise<Store> {
-    return Filesystem.readJson<Store>(file).catch(() => ({}) as Store)
-  }
-
-  async function row(item: Touch): Promise<Row> {
-    return {
-      ...item,
-      core: await entryCore(item),
-    }
-  }
-
-  function next(prev: Entry | undefined, core: Core, now: number): { state: State; entry: Entry } {
-    const entry: Entry = {
-      ...core,
-      first_time: prev?.first_time ?? now,
-      last_time: now,
-      time_changed: prev?.time_changed ?? now,
-      load_count: (prev?.load_count ?? 0) + 1,
-      fingerprint: fingerprint(core),
-      themes: prev?.themes,
-    }
-    const state: State = !prev ? "first" : prev.fingerprint === entry.fingerprint ? "same" : "updated"
-    if (state === "updated") entry.time_changed = now
-    return {
-      state,
-      entry,
-    }
-  }
-
-  export async function touchMany(items: Touch[]): Promise<Array<{ state: State; entry: Entry }>> {
-    if (!items.length) return []
-    const file = storePath()
-    const rows = await Promise.all(items.map((item) => row(item)))
-
-    return Flock.withLock(lock(file), async () => {
-      const store = await read(file)
-      const now = Date.now()
-      const out: Array<{ state: State; entry: Entry }> = []
-      for (const item of rows) {
-        const hit = next(store[item.id], item.core, now)
-        store[item.id] = hit.entry
-        out.push(hit)
-      }
-      await Filesystem.writeJson(file, store)
-      return out
-    })
-  }
-
-  export async function touch(spec: string, target: string, id: string): Promise<{ state: State; entry: Entry }> {
-    return touchMany([{ spec, target, id }]).then((item) => {
-      const hit = item[0]
-      if (hit) return hit
-      throw new Error("Failed to touch plugin metadata.")
-    })
-  }
-
-  export async function setTheme(id: string, name: string, theme: Theme): Promise<void> {
-    const file = storePath()
-    await Flock.withLock(lock(file), async () => {
-      const store = await read(file)
-      const entry = store[id]
-      if (!entry) return
-      entry.themes = {
-        ...(entry.themes ?? {}),
-        [name]: theme,
-      }
-      await Filesystem.writeJson(file, store)
-    })
-  }
-
-  export async function list(): Promise<Store> {
-    const file = storePath()
-    return Flock.withLock(lock(file), async () => read(file))
-  }
-}

package/src/plugin/shared.ts

@@ -1,272 +0,0 @@
-import path from "path"
-import { fileURLToPath, pathToFileURL } from "url"
-import semver from "semver"
-import { BunProc } from "@/bun"
-import { Filesystem } from "@/util/filesystem"
-import { isRecord } from "@/util/record"
-
-// Old npm package names for plugins that are now built-in
-export const DEPRECATED_PLUGIN_PACKAGES = ["opencode-openai-codex-auth", "opencode-copilot-auth"]
-
-export function isDeprecatedPlugin(spec: string) {
-  return DEPRECATED_PLUGIN_PACKAGES.some((pkg) => spec.includes(pkg))
-}
-
-export function parsePluginSpecifier(spec: string) {
-  const lastAt = spec.lastIndexOf("@")
-  const pkg = lastAt > 0 ? spec.substring(0, lastAt) : spec
-  const version = lastAt > 0 ? spec.substring(lastAt + 1) : "latest"
-  return { pkg, version }
-}
-
-export type PluginSource = "file" | "npm"
-export type PluginKind = "server" | "tui"
-type PluginMode = "strict" | "detect"
-
-export type PluginPackage = {
-  dir: string
-  pkg: string
-  json: Record<string, unknown>
-}
-
-export type PluginEntry = {
-  spec: string
-  source: PluginSource
-  target: string
-  pkg?: PluginPackage
-  entry?: string
-}
-
-const INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.mjs", "index.cjs"]
-
-export function pluginSource(spec: string): PluginSource {
-  if (isPathPluginSpec(spec)) return "file"
-  return "npm"
-}
-
-function resolveExportPath(raw: string, dir: string) {
-  if (raw.startsWith("file://")) return fileURLToPath(raw)
-  if (path.isAbsolute(raw)) return raw
-  return path.resolve(dir, raw)
-}
-
-function extractExportValue(value: unknown): string | undefined {
-  if (typeof value === "string") return value
-  if (!isRecord(value)) return undefined
-  for (const key of ["import", "default"]) {
-    const nested = value[key]
-    if (typeof nested === "string") return nested
-  }
-  return undefined
-}
-
-function packageMain(pkg: PluginPackage) {
-  const value = pkg.json.main
-  if (typeof value !== "string") return
-  const next = value.trim()
-  if (!next) return
-  return next
-}
-
-function resolvePackagePath(spec: string, raw: string, kind: PluginKind, pkg: PluginPackage) {
-  const resolved = resolveExportPath(raw, pkg.dir)
-  const root = Filesystem.resolve(pkg.dir)
-  const next = Filesystem.resolve(resolved)
-  if (!Filesystem.contains(root, next)) {
-    throw new Error(`Plugin ${spec} resolved ${kind} entry outside plugin directory`)
-  }
-  return pathToFileURL(next).href
-}
-
-function resolvePackageEntrypoint(spec: string, kind: PluginKind, pkg: PluginPackage) {
-  const exports = pkg.json.exports
-  if (isRecord(exports)) {
-    const raw = extractExportValue(exports[`./${kind}`])
-    if (raw) return resolvePackagePath(spec, raw, kind, pkg)
-  }
-
-  if (kind !== "server") return
-  const main = packageMain(pkg)
-  if (!main) return
-  return resolvePackagePath(spec, main, kind, pkg)
-}
-
-function targetPath(target: string) {
-  if (target.startsWith("file://")) return fileURLToPath(target)
-  if (path.isAbsolute(target)) return target
-}
-
-async function resolveDirectoryIndex(dir: string) {
-  for (const name of INDEX_FILES) {
-    const file = path.join(dir, name)
-    if (await Filesystem.exists(file)) return file
-  }
-}
-
-async function resolveTargetDirectory(target: string) {
-  const file = targetPath(target)
-  if (!file) return
-  const stat = await Filesystem.stat(file)
-  if (!stat?.isDirectory()) return
-  return file
-}
-
-async function resolvePluginEntrypoint(spec: string, target: string, kind: PluginKind, pkg?: PluginPackage) {
-  const source = pluginSource(spec)
-  const hit =
-    pkg ?? (source === "npm" ? await readPluginPackage(target) : await readPluginPackage(target).catch(() => undefined))
-  if (!hit) return target
-
-  const entry = resolvePackageEntrypoint(spec, kind, hit)
-  if (entry) return entry
-
-  const dir = await resolveTargetDirectory(target)
-
-  if (kind === "tui") {
-    if (source === "file" && dir) {
-      const index = await resolveDirectoryIndex(dir)
-      if (index) return pathToFileURL(index).href
-    }
-
-    if (source === "npm") return
-    if (dir) return
-
-    return target
-  }
-
-  if (dir && isRecord(hit.json.exports)) {
-    if (source === "file") {
-      const index = await resolveDirectoryIndex(dir)
-      if (index) return pathToFileURL(index).href
-    }
-
-    return
-  }
-
-  return target
-}
-
-export function isPathPluginSpec(spec: string) {
-  return spec.startsWith("file://") || spec.startsWith(".") || path.isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec)
-}
-
-export async function resolvePathPluginTarget(spec: string) {
-  const raw = spec.startsWith("file://") ? fileURLToPath(spec) : spec
-  const file = path.isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw) ? raw : path.resolve(raw)
-  const stat = await Filesystem.stat(file)
-  if (!stat?.isDirectory()) {
-    if (spec.startsWith("file://")) return spec
-    return pathToFileURL(file).href
-  }
-
-  if (await Filesystem.exists(path.join(file, "package.json"))) {
-    return pathToFileURL(file).href
-  }
-
-  const index = await resolveDirectoryIndex(file)
-  if (index) return pathToFileURL(index).href
-
-  throw new Error(`Plugin directory ${file} is missing package.json or index file`)
-}
-
-export async function checkPluginCompatibility(target: string, opencodeVersion: string, pkg?: PluginPackage) {
-  if (!semver.valid(opencodeVersion) || semver.major(opencodeVersion) === 0) return
-  const hit = pkg ?? (await readPluginPackage(target).catch(() => undefined))
-  if (!hit) return
-  const engines = hit.json.engines
-  if (!isRecord(engines)) return
-  const range = engines.opencode
-  if (typeof range !== "string") return
-  if (!semver.satisfies(opencodeVersion, range)) {
-    throw new Error(`Plugin requires opencode ${range} but running ${opencodeVersion}`)
-  }
-}
-
-export async function resolvePluginTarget(spec: string, parsed = parsePluginSpecifier(spec)) {
-  if (isPathPluginSpec(spec)) return resolvePathPluginTarget(spec)
-  return BunProc.install(parsed.pkg, parsed.version, { ignoreScripts: true })
-}
-
-export async function readPluginPackage(target: string): Promise<PluginPackage> {
-  const file = target.startsWith("file://") ? fileURLToPath(target) : target
-  const stat = await Filesystem.stat(file)
-  const dir = stat?.isDirectory() ? file : path.dirname(file)
-  const pkg = path.join(dir, "package.json")
-  const json = await Filesystem.readJson<Record<string, unknown>>(pkg)
-  return { dir, pkg, json }
-}
-
-export async function createPluginEntry(spec: string, target: string, kind: PluginKind): Promise<PluginEntry> {
-  const source = pluginSource(spec)
-  const pkg =
-    source === "npm" ? await readPluginPackage(target) : await readPluginPackage(target).catch(() => undefined)
-  const entry = await resolvePluginEntrypoint(spec, target, kind, pkg)
-  return {
-    spec,
-    source,
-    target,
-    pkg,
-    entry,
-  }
-}
-
-export function readPluginId(id: unknown, spec: string) {
-  if (id === undefined) return
-  if (typeof id !== "string") throw new TypeError(`Plugin ${spec} has invalid id type ${typeof id}`)
-  const value = id.trim()
-  if (!value) throw new TypeError(`Plugin ${spec} has an empty id`)
-  return value
-}
-
-export function readV1Plugin(
-  mod: Record<string, unknown>,
-  spec: string,
-  kind: PluginKind,
-  mode: PluginMode = "strict",
-) {
-  const value = mod.default
-  if (!isRecord(value)) {
-    if (mode === "detect") return
-    throw new TypeError(`Plugin ${spec} must default export an object with ${kind}()`)
-  }
-  if (mode === "detect" && !("id" in value) && !("server" in value) && !("tui" in value)) return
-
-  const server = "server" in value ? value.server : undefined
-  const tui = "tui" in value ? value.tui : undefined
-  if (server !== undefined && typeof server !== "function") {
-    throw new TypeError(`Plugin ${spec} has invalid server export`)
-  }
-  if (tui !== undefined && typeof tui !== "function") {
-    throw new TypeError(`Plugin ${spec} has invalid tui export`)
-  }
-  if (server !== undefined && tui !== undefined) {
-    throw new TypeError(`Plugin ${spec} must default export either server() or tui(), not both`)
-  }
-  if (kind === "server" && server === undefined) {
-    throw new TypeError(`Plugin ${spec} must default export an object with server()`)
-  }
-  if (kind === "tui" && tui === undefined) {
-    throw new TypeError(`Plugin ${spec} must default export an object with tui()`)
-  }
-
-  return value
-}
-
-export async function resolvePluginId(
-  source: PluginSource,
-  spec: string,
-  target: string,
-  id: string | undefined,
-  pkg?: PluginPackage,
-) {
-  if (source === "file") {
-    if (id) return id
-    throw new TypeError(`Path plugin ${spec} must export id`)
-  }
-  if (id) return id
-  const hit = pkg ?? (await readPluginPackage(target))
-  if (typeof hit.json.name !== "string" || !hit.json.name.trim()) {
-    throw new TypeError(`Plugin package ${hit.pkg} is missing name`)
-  }
-  return hit.json.name.trim()
-}

package/src/project/bootstrap.ts

@@ -1,31 +0,0 @@
-import { Plugin } from "../plugin"
-import { Format } from "../format"
-import { LSP } from "../lsp"
-import { File } from "../file"
-import { FileWatcher } from "../file/watcher"
-import { Snapshot } from "../snapshot"
-import { Project } from "./project"
-import { Vcs } from "./vcs"
-import { Bus } from "../bus"
-import { Command } from "../command"
-import { Instance } from "./instance"
-import { Log } from "@/util/log"
-import { ShareNext } from "@/share/share-next"
-
-export async function InstanceBootstrap() {
-  Log.Default.info("bootstrapping", { directory: Instance.directory })
-  await Plugin.init()
-  ShareNext.init()
-  Format.init()
-  await LSP.init()
-  File.init()
-  FileWatcher.init()
-  Vcs.init()
-  Snapshot.init()
-
-  Bus.subscribe(Command.Event.Executed, async (payload) => {
-    if (payload.properties.name === Command.Default.INIT) {
-      Project.setInitialized(Instance.project.id)
-    }
-  })
-}

package/src/project/instance.ts

@@ -1,167 +0,0 @@
-import { GlobalBus } from "@/bus/global"
-import { disposeInstance } from "@/effect/instance-registry"
-import { Filesystem } from "@/util/filesystem"
-import { iife } from "@/util/iife"
-import { Log } from "@/util/log"
-import { Context } from "../util/context"
-import { Project } from "./project"
-import { State } from "./state"
-
-export interface InstanceContext {
-  directory: string
-  worktree: string
-  project: Project.Info
-}
-
-const context = Context.create<InstanceContext>("instance")
-const cache = new Map<string, Promise<InstanceContext>>()
-
-const disposal = {
-  all: undefined as Promise<void> | undefined,
-}
-
-function emit(directory: string) {
-  GlobalBus.emit("event", {
-    directory,
-    payload: {
-      type: "server.instance.disposed",
-      properties: {
-        directory,
-      },
-    },
-  })
-}
-
-function boot(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
-  return iife(async () => {
-    const ctx =
-      input.project && input.worktree
-        ? {
-            directory: input.directory,
-            worktree: input.worktree,
-            project: input.project,
-          }
-        : await Project.fromDirectory(input.directory).then(({ project, sandbox }) => ({
-            directory: input.directory,
-            worktree: sandbox,
-            project,
-          }))
-    await context.provide(ctx, async () => {
-      await input.init?.()
-    })
-    return ctx
-  })
-}
-
-function track(directory: string, next: Promise<InstanceContext>) {
-  const task = next.catch((error) => {
-    if (cache.get(directory) === task) cache.delete(directory)
-    throw error
-  })
-  cache.set(directory, task)
-  return task
-}
-
-export const Instance = {
-  async provide<R>(input: { directory: string; init?: () => Promise<any>; fn: () => R }): Promise<R> {
-    const directory = Filesystem.resolve(input.directory)
-    let existing = cache.get(directory)
-    if (!existing) {
-      Log.Default.info("creating instance", { directory })
-      existing = track(
-        directory,
-        boot({
-          directory,
-          init: input.init,
-        }),
-      )
-    }
-    const ctx = await existing
-    return context.provide(ctx, async () => {
-      return input.fn()
-    })
-  },
-  get current() {
-    return context.use()
-  },
-  get directory() {
-    return context.use().directory
-  },
-  get worktree() {
-    return context.use().worktree
-  },
-  get project() {
-    return context.use().project
-  },
-  /**
-   * Check if a path is within the project boundary.
-   * Returns true if path is inside Instance.directory OR Instance.worktree.
-   * Paths within the worktree but outside the working directory should not trigger external_directory permission.
-   */
-  containsPath(filepath: string) {
-    if (Filesystem.contains(Instance.directory, filepath)) return true
-    // Non-git projects set worktree to "/" which would match ANY absolute path.
-    // Skip worktree check in this case to preserve external_directory permissions.
-    if (Instance.worktree === "/") return false
-    return Filesystem.contains(Instance.worktree, filepath)
-  },
-  /**
-   * Captures the current instance ALS context and returns a wrapper that
-   * restores it when called. Use this for callbacks that fire outside the
-   * instance async context (native addons, event emitters, timers, etc.).
-   */
-  bind<F extends (...args: any[]) => any>(fn: F): F {
-    const ctx = context.use()
-    return ((...args: any[]) => context.provide(ctx, () => fn(...args))) as F
-  },
-  state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): () => S {
-    return State.create(() => Instance.directory, init, dispose)
-  },
-  async reload(input: { directory: string; init?: () => Promise<any>; project?: Project.Info; worktree?: string }) {
-    const directory = Filesystem.resolve(input.directory)
-    Log.Default.info("reloading instance", { directory })
-    await Promise.all([State.dispose(directory), disposeInstance(directory)])
-    cache.delete(directory)
-    const next = track(directory, boot({ ...input, directory }))
-    emit(directory)
-    return await next
-  },
-  async dispose() {
-    const directory = Instance.directory
-    Log.Default.info("disposing instance", { directory })
-    await Promise.all([State.dispose(directory), disposeInstance(directory)])
-    cache.delete(directory)
-    emit(directory)
-  },
-  async disposeAll() {
-    if (disposal.all) return disposal.all
-
-    disposal.all = iife(async () => {
-      Log.Default.info("disposing all instances")
-      const entries = [...cache.entries()]
-      for (const [key, value] of entries) {
-        if (cache.get(key) !== value) continue
-
-        const ctx = await value.catch((error) => {
-          Log.Default.warn("instance dispose failed", { key, error })
-          return undefined
-        })
-
-        if (!ctx) {
-          if (cache.get(key) === value) cache.delete(key)
-          continue
-        }
-
-        if (cache.get(key) !== value) continue
-
-        await context.provide(ctx, async () => {
-          await Instance.dispose()
-        })
-      }
-    }).finally(() => {
-      disposal.all = undefined
-    })
-
-    return disposal.all
-  },
-}

package/src/project/project.sql.ts

@@ -1,16 +0,0 @@
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
-import { Timestamps } from "../storage/schema.sql"
-import type { ProjectID } from "./schema"
-
-export const ProjectTable = sqliteTable("project", {
-  id: text().$type<ProjectID>().primaryKey(),
-  worktree: text().notNull(),
-  vcs: text(),
-  name: text(),
-  icon_url: text(),
-  icon_color: text(),
-  ...Timestamps,
-  time_initialized: integer(),
-  sandboxes: text({ mode: "json" }).notNull().$type<string[]>(),
-  commands: text({ mode: "json" }).$type<{ start?: string }>(),
-})