@vikasitai/vikasit-code 2.0.4 → 2.0.5

package/src/plugin/copilot.ts

@@ -0,0 +1,343 @@
+import type { Hooks, PluginInput } from "@vikasit-code/plugin"
+import { Installation } from "@/installation"
+import { iife } from "@/util/iife"
+import { setTimeout as sleep } from "node:timers/promises"
+
+const CLIENT_ID = "Ov23li8tweQw6odWQebz"
+// Add a small safety buffer when polling to avoid hitting the server
+// slightly too early due to clock skew / timer drift.
+const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000 // 3 seconds
+function normalizeDomain(url: string) {
+  return url.replace(/^https?:\/\//, "").replace(/\/$/, "")
+}
+
+function getUrls(domain: string) {
+  return {
+    DEVICE_CODE_URL: `https://${domain}/login/device/code`,
+    ACCESS_TOKEN_URL: `https://${domain}/login/oauth/access_token`,
+  }
+}
+
+export async function CopilotAuthPlugin(input: PluginInput): Promise<Hooks> {
+  const sdk = input.client
+  return {
+    auth: {
+      provider: "github-copilot",
+      async loader(getAuth, provider) {
+        const info = await getAuth()
+        if (!info || info.type !== "oauth") return {}
+
+        const enterpriseUrl = info.enterpriseUrl
+        const baseURL = enterpriseUrl ? `https://copilot-api.${normalizeDomain(enterpriseUrl)}` : undefined
+
+        if (provider && provider.models) {
+          for (const model of Object.values(provider.models)) {
+            model.cost = {
+              input: 0,
+              output: 0,
+              cache: {
+                read: 0,
+                write: 0,
+              },
+            }
+
+            // TODO: re-enable once messages api has higher rate limits
+            // TODO: move some of this hacky-ness to models.dev presets once we have better grasp of things here...
+            // const base = baseURL ?? model.api.url
+            // const claude = model.id.includes("claude")
+            // const url = iife(() => {
+            //   if (!claude) return base
+            //   if (base.endsWith("/v1")) return base
+            //   if (base.endsWith("/")) return `${base}v1`
+            //   return `${base}/v1`
+            // })
+
+            // model.api.url = url
+            // model.api.npm = claude ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot"
+            model.api.npm = "@ai-sdk/github-copilot"
+          }
+        }
+
+        return {
+          baseURL,
+          apiKey: "",
+          async fetch(request: RequestInfo | URL, init?: RequestInit) {
+            const info = await getAuth()
+            if (info.type !== "oauth") return fetch(request, init)
+
+            const url = request instanceof URL ? request.href : request.toString()
+            const { isVision, isAgent } = iife(() => {
+              try {
+                const body = typeof init?.body === "string" ? JSON.parse(init.body) : init?.body
+
+                // Completions API
+                if (body?.messages && url.includes("completions")) {
+                  const last = body.messages[body.messages.length - 1]
+                  return {
+                    isVision: body.messages.some(
+                      (msg: any) =>
+                        Array.isArray(msg.content) && msg.content.some((part: any) => part.type === "image_url"),
+                    ),
+                    isAgent: last?.role !== "user",
+                  }
+                }
+
+                // Responses API
+                if (body?.input) {
+                  const last = body.input[body.input.length - 1]
+                  return {
+                    isVision: body.input.some(
+                      (item: any) =>
+                        Array.isArray(item?.content) && item.content.some((part: any) => part.type === "input_image"),
+                    ),
+                    isAgent: last?.role !== "user",
+                  }
+                }
+
+                // Messages API
+                if (body?.messages) {
+                  const last = body.messages[body.messages.length - 1]
+                  const hasNonToolCalls =
+                    Array.isArray(last?.content) && last.content.some((part: any) => part?.type !== "tool_result")
+                  return {
+                    isVision: body.messages.some(
+                      (item: any) =>
+                        Array.isArray(item?.content) &&
+                        item.content.some(
+                          (part: any) =>
+                            part?.type === "image" ||
+                            // images can be nested inside tool_result content
+                            (part?.type === "tool_result" &&
+                              Array.isArray(part?.content) &&
+                              part.content.some((nested: any) => nested?.type === "image")),
+                        ),
+                    ),
+                    isAgent: !(last?.role === "user" && hasNonToolCalls),
+                  }
+                }
+              } catch {}
+              return { isVision: false, isAgent: false }
+            })
+
+            const headers: Record<string, string> = {
+              "x-initiator": isAgent ? "agent" : "user",
+              ...(init?.headers as Record<string, string>),
+              "User-Agent": `opencode/${Installation.VERSION}`,
+              Authorization: `Bearer ${info.refresh}`,
+              "Openai-Intent": "conversation-edits",
+            }
+
+            if (isVision) {
+              headers["Copilot-Vision-Request"] = "true"
+            }
+
+            delete headers["x-api-key"]
+            delete headers["authorization"]
+
+            return fetch(request, {
+              ...init,
+              headers,
+            })
+          },
+        }
+      },
+      methods: [
+        {
+          type: "oauth",
+          label: "Login with GitHub Copilot",
+          prompts: [
+            {
+              type: "select",
+              key: "deploymentType",
+              message: "Select GitHub deployment type",
+              options: [
+                {
+                  label: "GitHub.com",
+                  value: "github.com",
+                  hint: "Public",
+                },
+                {
+                  label: "GitHub Enterprise",
+                  value: "enterprise",
+                  hint: "Data residency or self-hosted",
+                },
+              ],
+            },
+            {
+              type: "text",
+              key: "enterpriseUrl",
+              message: "Enter your GitHub Enterprise URL or domain",
+              placeholder: "company.ghe.com or https://company.ghe.com",
+              when: { key: "deploymentType", op: "eq", value: "enterprise" },
+              validate: (value) => {
+                if (!value) return "URL or domain is required"
+                try {
+                  const url = value.includes("://") ? new URL(value) : new URL(`https://${value}`)
+                  if (!url.hostname) return "Please enter a valid URL or domain"
+                  return undefined
+                } catch {
+                  return "Please enter a valid URL (e.g., company.ghe.com or https://company.ghe.com)"
+                }
+              },
+            },
+          ],
+          async authorize(inputs = {}) {
+            const deploymentType = inputs.deploymentType || "github.com"
+
+            let domain = "github.com"
+
+            if (deploymentType === "enterprise") {
+              const enterpriseUrl = inputs.enterpriseUrl
+              domain = normalizeDomain(enterpriseUrl!)
+            }
+
+            const urls = getUrls(domain)
+
+            const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
+              method: "POST",
+              headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": `opencode/${Installation.VERSION}`,
+              },
+              body: JSON.stringify({
+                client_id: CLIENT_ID,
+                scope: "read:user",
+              }),
+            })
+
+            if (!deviceResponse.ok) {
+              throw new Error("Failed to initiate device authorization")
+            }
+
+            const deviceData = (await deviceResponse.json()) as {
+              verification_uri: string
+              user_code: string
+              device_code: string
+              interval: number
+            }
+
+            return {
+              url: deviceData.verification_uri,
+              instructions: `Enter code: ${deviceData.user_code}`,
+              method: "auto" as const,
+              async callback() {
+                while (true) {
+                  const response = await fetch(urls.ACCESS_TOKEN_URL, {
+                    method: "POST",
+                    headers: {
+                      Accept: "application/json",
+                      "Content-Type": "application/json",
+                      "User-Agent": `opencode/${Installation.VERSION}`,
+                    },
+                    body: JSON.stringify({
+                      client_id: CLIENT_ID,
+                      device_code: deviceData.device_code,
+                      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    }),
+                  })
+
+                  if (!response.ok) return { type: "failed" as const }
+
+                  const data = (await response.json()) as {
+                    access_token?: string
+                    error?: string
+                    interval?: number
+                  }
+
+                  if (data.access_token) {
+                    const result: {
+                      type: "success"
+                      refresh: string
+                      access: string
+                      expires: number
+                      provider?: string
+                      enterpriseUrl?: string
+                    } = {
+                      type: "success",
+                      refresh: data.access_token,
+                      access: data.access_token,
+                      expires: 0,
+                    }
+
+                    if (deploymentType === "enterprise") {
+                      result.enterpriseUrl = domain
+                    }
+
+                    return result
+                  }
+
+                  if (data.error === "authorization_pending") {
+                    await sleep(deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS)
+                    continue
+                  }
+
+                  if (data.error === "slow_down") {
+                    // Based on the RFC spec, we must add 5 seconds to our current polling interval.
+                    // (See https://www.rfc-editor.org/rfc/rfc8628#section-3.5)
+                    let newInterval = (deviceData.interval + 5) * 1000
+
+                    // GitHub OAuth API may return the new interval in seconds in the response.
+                    // We should try to use that if provided with safety margin.
+                    const serverInterval = data.interval
+                    if (serverInterval && typeof serverInterval === "number" && serverInterval > 0) {
+                      newInterval = serverInterval * 1000
+                    }
+
+                    await sleep(newInterval + OAUTH_POLLING_SAFETY_MARGIN_MS)
+                    continue
+                  }
+
+                  if (data.error) return { type: "failed" as const }
+
+                  await sleep(deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS)
+                  continue
+                }
+              },
+            }
+          },
+        },
+      ],
+    },
+    "chat.headers": async (incoming, output) => {
+      if (!incoming.model.providerID.includes("github-copilot")) return
+
+      if (incoming.model.api.npm === "@ai-sdk/anthropic") {
+        output.headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+      }
+
+      const parts = await sdk.session
+        .message({
+          path: {
+            id: incoming.message.sessionID,
+            messageID: incoming.message.id,
+          },
+          query: {
+            directory: input.directory,
+          },
+          throwOnError: true,
+        })
+        .catch(() => undefined)
+
+      if (parts?.data.parts?.some((part) => part.type === "compaction")) {
+        output.headers["x-initiator"] = "agent"
+        return
+      }
+
+      const session = await sdk.session
+        .get({
+          path: {
+            id: incoming.sessionID,
+          },
+          query: {
+            directory: input.directory,
+          },
+          throwOnError: true,
+        })
+        .catch(() => undefined)
+      if (!session || !session.data.parentID) return
+      // mark subagent sessions as agent initiated matching standard that other copilot tools have
+      output.headers["x-initiator"] = "agent"
+    },
+  }
+}

package/src/plugin/index.ts

@@ -0,0 +1,322 @@
+import type { Hooks, PluginInput, Plugin as PluginInstance, PluginModule } from "@vikasit-code/plugin"
+import { Config } from "../config/config"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+import { createOpencodeClient } from "@vikasit-code/sdk"
+import { Flag } from "../flag/flag"
+import { CodexAuthPlugin } from "./codex"
+import { Session } from "../session"
+import { NamedError } from "@vikasit-code/util/error"
+import { CopilotAuthPlugin } from "./copilot"
+import { gitlabAuthPlugin as GitlabAuthPlugin } from "opencode-gitlab-auth"
+import { PoeAuthPlugin } from "opencode-poe-auth"
+import { Effect, Layer, ServiceMap, Stream } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { errorMessage } from "@/util/error"
+import { PluginLoader } from "./loader"
+import { parsePluginSpecifier, readPluginId, readV1Plugin, resolvePluginId } from "./shared"
+
+export namespace Plugin {
+  const log = Log.create({ service: "plugin" })
+
+  type State = {
+    hooks: Hooks[]
+  }
+
+  type Loaded = {
+    row: PluginLoader.Loaded
+  }
+
+  // Hook names that follow the (input, output) => Promise<void> trigger pattern
+  type TriggerName = {
+    [K in keyof Hooks]-?: NonNullable<Hooks[K]> extends (input: any, output: any) => Promise<void> ? K : never
+  }[keyof Hooks]
+
+  export interface Interface {
+    readonly trigger: <
+      Name extends TriggerName,
+      Input = Parameters<Required<Hooks>[Name]>[0],
+      Output = Parameters<Required<Hooks>[Name]>[1],
+    >(
+      name: Name,
+      input: Input,
+      output: Output,
+    ) => Effect.Effect<Output>
+    readonly list: () => Effect.Effect<Hooks[]>
+    readonly init: () => Effect.Effect<void>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Plugin") {}
+
+  // Built-in plugins that are directly imported (not installed from npm)
+  const INTERNAL_PLUGINS: PluginInstance[] = [CodexAuthPlugin, CopilotAuthPlugin, GitlabAuthPlugin as unknown as PluginInstance, PoeAuthPlugin as unknown as PluginInstance]
+
+  function isServerPlugin(value: unknown): value is PluginInstance {
+    return typeof value === "function"
+  }
+
+  function getServerPlugin(value: unknown) {
+    if (isServerPlugin(value)) return value
+    if (!value || typeof value !== "object" || !("server" in value)) return
+    if (!isServerPlugin(value.server)) return
+    return value.server
+  }
+
+  function getLegacyPlugins(mod: Record<string, unknown>) {
+    const seen = new Set<unknown>()
+    const result: PluginInstance[] = []
+
+    for (const entry of Object.values(mod)) {
+      if (seen.has(entry)) continue
+      seen.add(entry)
+      const plugin = getServerPlugin(entry)
+      if (!plugin) throw new TypeError("Plugin export is not a function")
+      result.push(plugin)
+    }
+
+    return result
+  }
+
+  async function applyPlugin(load: Loaded, input: PluginInput, hooks: Hooks[]) {
+    const plugin = readV1Plugin(load.row.mod, load.row.spec, "server", "detect")
+    if (plugin) {
+      await resolvePluginId(
+        load.row.source,
+        load.row.spec,
+        load.row.target,
+        readPluginId(plugin.id, load.row.spec),
+        load.row.pkg,
+      )
+      hooks.push(await (plugin as PluginModule).server(input, load.row.options))
+      return
+    }
+
+    for (const server of getLegacyPlugins(load.row.mod)) {
+      hooks.push(await server(input, load.row.options))
+    }
+  }
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const config = yield* Config.Service
+
+      const cache = yield* InstanceState.make<State>(
+        Effect.fn("Plugin.state")(function* (ctx) {
+          const hooks: Hooks[] = []
+
+          const { Server } = yield* Effect.promise(() => import("../server/server"))
+
+          const client = createOpencodeClient({
+            baseUrl: "http://localhost:4096",
+            directory: ctx.directory,
+            headers: Flag.VIKASIT_SERVER_PASSWORD
+              ? {
+                  Authorization: `Basic ${Buffer.from(`${Flag.VIKASIT_SERVER_USERNAME ?? "vikasit"}:${Flag.VIKASIT_SERVER_PASSWORD}`).toString("base64")}`,
+                }
+              : undefined,
+            fetch: async (...args) => Server.Default().fetch(...args),
+          })
+          const cfg = yield* config.get()
+          const input: PluginInput = {
+            client,
+            project: ctx.project,
+            worktree: ctx.worktree,
+            directory: ctx.directory,
+            get serverUrl(): URL {
+              return Server.url ?? new URL("http://localhost:4096")
+            },
+            $: Bun.$,
+          }
+
+          for (const plugin of INTERNAL_PLUGINS) {
+            log.info("loading internal plugin", { name: plugin.name })
+            const init = yield* Effect.tryPromise({
+              try: () => plugin(input),
+              catch: (err) => {
+                log.error("failed to load internal plugin", { name: plugin.name, error: err })
+              },
+            }).pipe(Effect.option)
+            if (init._tag === "Some") hooks.push(init.value)
+          }
+
+          const plugins = Flag.VIKASIT_PURE ? [] : (cfg.plugin ?? [])
+          if (Flag.VIKASIT_PURE && cfg.plugin?.length) {
+            log.info("skipping external plugins in pure mode", { count: cfg.plugin.length })
+          }
+          if (plugins.length) yield* config.waitForDependencies()
+
+          const loaded = yield* Effect.promise(() =>
+            Promise.all(
+              plugins.map(async (item) => {
+                const plan = PluginLoader.plan(item)
+                if (plan.deprecated) return
+                log.info("loading plugin", { path: plan.spec })
+
+                const resolved = await PluginLoader.resolve(plan, "server")
+                if (!resolved.ok) {
+                  if (resolved.stage === "missing") {
+                    log.warn("plugin has no server entrypoint", {
+                      path: plan.spec,
+                      message: resolved.message,
+                    })
+                    return
+                  }
+
+                  const cause =
+                    resolved.error instanceof Error ? (resolved.error.cause ?? resolved.error) : resolved.error
+                  const message = errorMessage(cause)
+
+                  if (resolved.stage === "install") {
+                    const parsed = parsePluginSpecifier(plan.spec)
+                    log.error("failed to install plugin", {
+                      pkg: parsed.pkg,
+                      version: parsed.version,
+                      error: message,
+                    })
+                    Bus.publish(Session.Event.Error, {
+                      error: new NamedError.Unknown({
+                        message: `Failed to install plugin ${parsed.pkg}@${parsed.version}: ${message}`,
+                      }).toObject(),
+                    })
+                    return
+                  }
+
+                  if (resolved.stage === "compatibility") {
+                    log.warn("plugin incompatible", { path: plan.spec, error: message })
+                    Bus.publish(Session.Event.Error, {
+                      error: new NamedError.Unknown({
+                        message: `Plugin ${plan.spec} skipped: ${message}`,
+                      }).toObject(),
+                    })
+                    return
+                  }
+
+                  log.error("failed to resolve plugin server entry", {
+                    path: plan.spec,
+                    error: message,
+                  })
+                  Bus.publish(Session.Event.Error, {
+                    error: new NamedError.Unknown({
+                      message: `Failed to load plugin ${plan.spec}: ${message}`,
+                    }).toObject(),
+                  })
+                  return
+                }
+
+                const mod = await PluginLoader.load(resolved.value)
+                if (!mod.ok) {
+                  const message = errorMessage(mod.error)
+                  log.error("failed to load plugin", { path: plan.spec, target: resolved.value.entry, error: message })
+                  Bus.publish(Session.Event.Error, {
+                    error: new NamedError.Unknown({
+                      message: `Failed to load plugin ${plan.spec}: ${message}`,
+                    }).toObject(),
+                  })
+                  return
+                }
+
+                return {
+                  row: mod.value,
+                }
+              }),
+            ),
+          )
+          for (const load of loaded) {
+            if (!load) continue
+
+            // Keep plugin execution sequential so hook registration and execution
+            // order remains deterministic across plugin runs.
+            yield* Effect.tryPromise({
+              try: () => applyPlugin(load, input, hooks),
+              catch: (err) => {
+                const message = errorMessage(err)
+                log.error("failed to load plugin", { path: load.row.spec, error: message })
+                return message
+              },
+            }).pipe(
+              Effect.catch((message) =>
+                bus.publish(Session.Event.Error, {
+                  error: new NamedError.Unknown({
+                    message: `Failed to load plugin ${load.row.spec}: ${message}`,
+                  }).toObject(),
+                }),
+              ),
+            )
+          }
+
+          // Notify plugins of current config
+          for (const hook of hooks) {
+            yield* Effect.tryPromise({
+              try: () => Promise.resolve((hook as any).config?.(cfg)),
+              catch: (err) => {
+                log.error("plugin config hook failed", { error: err })
+              },
+            }).pipe(Effect.ignore)
+          }
+
+          // Subscribe to bus events, fiber interrupted when scope closes
+          yield* bus.subscribeAll().pipe(
+            Stream.runForEach((input) =>
+              Effect.sync(() => {
+                for (const hook of hooks) {
+                  hook["event"]?.({ event: input as any })
+                }
+              }),
+            ),
+            Effect.forkScoped,
+          )
+
+          return { hooks }
+        }),
+      )
+
+      const trigger = Effect.fn("Plugin.trigger")(function* <
+        Name extends TriggerName,
+        Input = Parameters<Required<Hooks>[Name]>[0],
+        Output = Parameters<Required<Hooks>[Name]>[1],
+      >(name: Name, input: Input, output: Output) {
+        if (!name) return output
+        const state = yield* InstanceState.get(cache)
+        for (const hook of state.hooks) {
+          const fn = hook[name] as any
+          if (!fn) continue
+          yield* Effect.promise(async () => fn(input, output))
+        }
+        return output
+      })
+
+      const list = Effect.fn("Plugin.list")(function* () {
+        const state = yield* InstanceState.get(cache)
+        return state.hooks
+      })
+
+      const init = Effect.fn("Plugin.init")(function* () {
+        yield* InstanceState.get(cache)
+      })
+
+      return Service.of({ trigger, list, init })
+    }),
+  )
+
+  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Config.defaultLayer))
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function trigger<
+    Name extends TriggerName,
+    Input = Parameters<Required<Hooks>[Name]>[0],
+    Output = Parameters<Required<Hooks>[Name]>[1],
+  >(name: Name, input: Input, output: Output): Promise<Output> {
+    return runPromise((svc) => svc.trigger(name, input, output))
+  }
+
+  export async function list(): Promise<Hooks[]> {
+    return runPromise((svc) => svc.list())
+  }
+
+  export async function init() {
+    return runPromise((svc) => svc.init())
+  }
+}