bonecode 1.0.0

package/src/engine/project/vcs.ts

@@ -0,0 +1,405 @@
+import { Effect, Layer, Context, Schema, Stream, Scope } from "effect"
+import { formatPatch, structuredPatch } from "diff"
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { InstanceState } from "@/effect/instance-state"
+import { FileWatcher } from "@/file/watcher"
+import { Git } from "@/git"
+import * as Log from "@opencode-ai/core/util/log"
+
+const log = Log.create({ service: "vcs" })
+const PATCH_CONTEXT_LINES = 2_147_483_647
+const MAX_PATCH_BYTES = 10_000_000
+const MAX_TOTAL_PATCH_BYTES = 10_000_000
+
+const emptyPatch = (file: string) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }))
+
+const nums = (list: Git.Stat[]) =>
+  new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }] as const))
+
+const merge = (...lists: Git.Item[][]) => {
+  const out = new Map<string, Git.Item>()
+  lists.flat().forEach((item) => {
+    if (!out.has(item.file)) out.set(item.file, item)
+  })
+  return [...out.values()]
+}
+
+const emptyBatch = () => ({ patches: new Map<string, string>(), capped: false })
+
+const parseQuotedPath = (value: string) => {
+  let out = ""
+  for (let idx = 1; idx < value.length; idx++) {
+    const char = value[idx]
+    if (char === '"') return { value: out, end: idx + 1 }
+    if (char !== "\\") {
+      out += char
+      continue
+    }
+
+    const next = value[++idx]
+    if (next === "t") out += "\t"
+    else if (next === "n") out += "\n"
+    else if (next === "r") out += "\r"
+    else if (next === '"' || next === "\\") out += next
+    else out += next ?? ""
+  }
+}
+
+const parsePathToken = (value: string) => {
+  if (!value.startsWith('"')) return value.split("\t")[0]
+  return parseQuotedPath(value)?.value ?? value
+}
+
+const fileFromDiffPath = (value: string | undefined) => {
+  if (!value || value === "/dev/null") return
+  const file = parsePathToken(value)
+  if (file.startsWith("a/") || file.startsWith("b/")) return file.slice(2)
+  return file
+}
+
+const fileFromGitHeader = (header: string) => {
+  if (header.startsWith('"')) {
+    const first = parseQuotedPath(header)
+    const second = first ? header.slice(first.end).trimStart() : undefined
+    if (!second) return
+    if (!second.startsWith('"')) return fileFromDiffPath(second)
+    return fileFromDiffPath(parseQuotedPath(second)?.value)
+  }
+
+  const separator = header.indexOf(" b/")
+  if (separator === -1) return
+  return fileFromDiffPath(header.slice(separator + 1))
+}
+
+const fileFromPatchChunk = (chunk: string) => {
+  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1]
+  const before = /^--- (.+)$/m.exec(chunk)?.[1]
+  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before)
+  if (file) return file
+
+  const header = /^diff --git (.+)$/m.exec(chunk)?.[1]
+  return fileFromGitHeader(header ?? "")
+}
+
+const splitGitPatch = (patch: Git.Patch) => {
+  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) =>
+    match[0].startsWith("\n") ? match.index + 1 : match.index,
+  )
+  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length))
+  if (!patch.truncated) return chunks
+  return chunks.slice(0, -1)
+}
+
+const batchPatches = Effect.fnUntraced(function* (git: Git.Interface, cwd: string, ref: string, list: Git.Item[]) {
+  if (list.length === 0) return { patches: new Map<string, string>(), capped: false }
+
+  const result = yield* git.patchAll(cwd, ref, {
+    context: PATCH_CONTEXT_LINES,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES,
+  })
+  if (result.truncated) log.warn("batched patch exceeded byte limit", { max: MAX_TOTAL_PATCH_BYTES })
+
+  return {
+    patches: splitGitPatch(result).reduce((acc, patch, index) => {
+      const file = fileFromPatchChunk(patch) ?? list[index]?.file
+      if (!file) return acc
+      acc.set(file, (acc.get(file) ?? "") + patch)
+      return acc
+    }, new Map<string, string>()),
+    capped: result.truncated,
+  }
+})
+
+const nativePatch = Effect.fnUntraced(function* (
+  git: Git.Interface,
+  cwd: string,
+  ref: string | undefined,
+  item: Git.Item,
+) {
+  const result =
+    item.code === "??" || !ref
+      ? yield* git.patchUntracked(cwd, item.file, { context: PATCH_CONTEXT_LINES, maxOutputBytes: MAX_PATCH_BYTES })
+      : yield* git.patch(cwd, ref, item.file, { context: PATCH_CONTEXT_LINES, maxOutputBytes: MAX_PATCH_BYTES })
+  if (!result.truncated && result.text) return result.text
+
+  if (result.truncated) log.warn("patch exceeded byte limit", { file: item.file, max: MAX_PATCH_BYTES })
+  return emptyPatch(item.file)
+})
+
+const totalPatch = (file: string, patch: string, total: number) => {
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES) return { patch, capped: false }
+  log.warn("total patch budget exceeded", { file, max: MAX_TOTAL_PATCH_BYTES })
+  return { patch: emptyPatch(file), capped: true }
+}
+
+const patchForItem = Effect.fnUntraced(function* (
+  git: Git.Interface,
+  cwd: string,
+  ref: string | undefined,
+  item: Git.Item,
+  batch: { patches: Map<string, string>; capped: boolean },
+  capped: boolean,
+) {
+  if (capped) return emptyPatch(item.file)
+
+  const batched = batch.patches.get(item.file)
+  if (batched !== undefined) return batched
+  if (item.code !== "??" && batch.capped) return emptyPatch(item.file)
+  return yield* nativePatch(git, cwd, ref, item)
+})
+
+const files = Effect.fnUntraced(function* (
+  git: Git.Interface,
+  cwd: string,
+  ref: string | undefined,
+  list: Git.Item[],
+  map: Map<string, { additions: number; deletions: number }>,
+  batch: { patches: Map<string, string>; capped: boolean },
+) {
+  const next: FileDiff[] = []
+  let total = 0
+  let capped = false
+
+  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
+    const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(cwd, item.file) : undefined)
+    const patch = yield* patchForItem(git, cwd, ref, item, batch, capped)
+    const result: { patch: string; capped: boolean } = capped
+      ? { patch, capped: true }
+      : totalPatch(item.file, patch, total)
+    capped = capped || result.capped
+    if (!capped) {
+      total += Buffer.byteLength(result.patch)
+      capped = total >= MAX_TOTAL_PATCH_BYTES
+    }
+    next.push({
+      file: item.file,
+      patch: result.patch,
+      additions: stat?.additions ?? 0,
+      deletions: stat?.deletions ?? 0,
+      status: item.status,
+    })
+  }
+
+  return next
+})
+
+const diffAgainstRef = Effect.fnUntraced(function* (git: Git.Interface, cwd: string, ref: string) {
+  const [list, stats, extra] = yield* Effect.all([git.diff(cwd, ref), git.stats(cwd, ref), git.status(cwd)], {
+    concurrency: 3,
+  })
+  return yield* files(
+    git,
+    cwd,
+    ref,
+    merge(
+      list,
+      extra.filter((item) => item.code === "??"),
+    ),
+    nums(stats),
+    yield* batchPatches(git, cwd, ref, list),
+  )
+})
+
+const track = Effect.fnUntraced(function* (git: Git.Interface, cwd: string, ref: string | undefined) {
+  if (!ref) return yield* files(git, cwd, ref, yield* git.status(cwd), new Map(), emptyBatch())
+  return yield* diffAgainstRef(git, cwd, ref)
+})
+
+export const Mode = Schema.Literals(["git", "branch"])
+export type Mode = Schema.Schema.Type<typeof Mode>
+
+export const Event = {
+  BranchUpdated: BusEvent.define(
+    "vcs.branch.updated",
+    Schema.Struct({
+      branch: Schema.optional(Schema.String),
+    }),
+  ),
+}
+
+export const Info = Schema.Struct({
+  branch: Schema.optional(Schema.String),
+  default_branch: Schema.optional(Schema.String),
+}).annotate({ identifier: "VcsInfo" })
+export type Info = Schema.Schema.Type<typeof Info>
+
+export const FileDiff = Schema.Struct({
+  file: Schema.String,
+  // Mirrors Snapshot.FileDiff (see #26574). The current producer always
+  // populates patch, but loosening matches the sibling schema so a
+  // future code path that omits it can't crash /instance/vcs/diff.
+  patch: Schema.optional(Schema.String),
+  additions: Schema.Finite,
+  deletions: Schema.Finite,
+  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
+}).annotate({ identifier: "VcsFileDiff" })
+export type FileDiff = Schema.Schema.Type<typeof FileDiff>
+
+export const FileStatus = Schema.Struct({
+  file: Schema.String,
+  additions: Schema.Finite,
+  deletions: Schema.Finite,
+  status: Schema.Literals(["added", "deleted", "modified"]),
+}).annotate({ identifier: "VcsFileStatus" })
+export type FileStatus = Schema.Schema.Type<typeof FileStatus>
+
+export const ApplyInput = Schema.Struct({
+  patch: Schema.String,
+})
+export type ApplyInput = Schema.Schema.Type<typeof ApplyInput>
+
+export const ApplyResult = Schema.Struct({
+  applied: Schema.Boolean,
+})
+export type ApplyResult = Schema.Schema.Type<typeof ApplyResult>
+
+export class PatchApplyError extends Schema.TaggedErrorClass<PatchApplyError>()("VcsPatchApplyError", {
+  message: Schema.String,
+  reason: Schema.Literals(["non-git", "not-clean"]),
+}) {}
+
+export interface Interface {
+  readonly init: () => Effect.Effect<void>
+  readonly branch: () => Effect.Effect<string | undefined>
+  readonly defaultBranch: () => Effect.Effect<string | undefined>
+  readonly status: () => Effect.Effect<FileStatus[]>
+  readonly diff: (mode: Mode) => Effect.Effect<FileDiff[]>
+  readonly diffRaw: () => Effect.Effect<string>
+  readonly apply: (input: ApplyInput) => Effect.Effect<ApplyResult, PatchApplyError>
+}
+
+interface State {
+  current: string | undefined
+  root: Git.Base | undefined
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Vcs") {}
+
+export const layer: Layer.Layer<Service, never, Git.Service | Bus.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const git = yield* Git.Service
+    const bus = yield* Bus.Service
+    const scope = yield* Scope.Scope
+
+    const state = yield* InstanceState.make<State>(
+      Effect.fn("Vcs.state")(function* (ctx) {
+        if (ctx.project.vcs !== "git") {
+          return { current: undefined, root: undefined }
+        }
+
+        const get = Effect.fnUntraced(function* () {
+          return yield* git.branch(ctx.directory)
+        })
+        const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
+          concurrency: 2,
+        })
+        const value = { current, root }
+        log.info("initialized", { branch: value.current, default_branch: value.root?.name })
+
+        yield* bus.subscribe(FileWatcher.Event.Updated).pipe(
+          Stream.filter((evt) => evt.properties.file.endsWith("HEAD")),
+          Stream.runForEach((_evt) =>
+            Effect.gen(function* () {
+              const next = yield* get()
+              if (next !== value.current) {
+                log.info("branch changed", { from: value.current, to: next })
+                value.current = next
+                yield* bus.publish(Event.BranchUpdated, { branch: next })
+              }
+            }),
+          ),
+          Effect.forkScoped,
+        )
+
+        return value
+      }),
+    )
+
+    return Service.of({
+      init: Effect.fn("Vcs.init")(function* () {
+        yield* InstanceState.get(state).pipe(Effect.forkIn(scope))
+      }),
+      branch: Effect.fn("Vcs.branch")(function* () {
+        return yield* InstanceState.use(state, (x) => x.current)
+      }),
+      defaultBranch: Effect.fn("Vcs.defaultBranch")(function* () {
+        return yield* InstanceState.use(state, (x) => x.root?.name)
+      }),
+      status: Effect.fn("Vcs.status")(function* () {
+        const ctx = yield* InstanceState.context
+        if (ctx.project.vcs !== "git") return []
+        const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined
+        const [list, stats] = yield* Effect.all(
+          [git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])],
+          { concurrency: 2 },
+        )
+        const map = nums(stats)
+        return yield* Effect.forEach(
+          list.toSorted((a, b) => a.file.localeCompare(b.file)),
+          (item) =>
+            Effect.gen(function* () {
+              const stat =
+                map.get(item.file) ??
+                (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined)
+              return {
+                file: item.file,
+                additions: stat?.additions ?? 0,
+                deletions: stat?.deletions ?? 0,
+                status: item.status,
+              } satisfies FileStatus
+            }),
+        )
+      }),
+      diff: Effect.fn("Vcs.diff")(function* (mode: Mode) {
+        const value = yield* InstanceState.get(state)
+        const ctx = yield* InstanceState.context
+        if (ctx.project.vcs !== "git") return []
+        if (mode === "git") {
+          return yield* track(git, ctx.directory, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined)
+        }
+
+        if (!value.root) return []
+        if (value.current && value.current === value.root.name) return []
+        const ref = yield* git.mergeBase(ctx.directory, value.root.ref)
+        if (!ref) return []
+        return yield* diffAgainstRef(git, ctx.directory, ref)
+      }),
+      diffRaw: Effect.fn("Vcs.diffRaw")(function* () {
+        const ctx = yield* InstanceState.context
+        if (ctx.project.vcs !== "git") return ""
+        const [hasHead, status] = yield* Effect.all([git.hasHead(ctx.directory), git.status(ctx.directory)], {
+          concurrency: 2,
+        })
+        const tracked = hasHead ? (yield* git.patchAll(ctx.directory, "HEAD")).text : ""
+        const untracked = yield* Effect.forEach(
+          status.filter((item) => item.code === "??"),
+          (item) => git.patchUntracked(ctx.directory, item.file).pipe(Effect.map((patch) => patch.text)),
+        )
+        return [tracked, ...untracked].filter(Boolean).join("\n")
+      }),
+      apply: Effect.fn("Vcs.apply")(function* (input: ApplyInput) {
+        const ctx = yield* InstanceState.context
+        if (ctx.project.vcs !== "git") {
+          return yield* new PatchApplyError({
+            message: "Patch can't be applied because the project is not git-based",
+            reason: "non-git",
+          })
+        }
+        const applied = yield* git.applyPatch(ctx.directory, input.patch)
+        if (applied.exitCode !== 0) {
+          return yield* new PatchApplyError({
+            message: "Patch can't be applied",
+            reason: "not-clean",
+          })
+        }
+        return { applied: true }
+      }),
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Git.defaultLayer), Layer.provide(Bus.layer))
+
+export * as Vcs from "./vcs"

package/src/engine/provider/auth.ts

@@ -0,0 +1,225 @@
+import type { AuthOAuthResult, Hooks } from "@opencode-ai/plugin"
+import { Auth } from "@/auth"
+import { InstanceState } from "@/effect/instance-state"
+import { optionalOmitUndefined } from "@opencode-ai/core/schema"
+import { Plugin } from "../plugin"
+import { ProviderID } from "./schema"
+import { Array as Arr, Effect, Layer, Record, Result, Context, Schema } from "effect"
+
+const When = Schema.Struct({
+  key: Schema.String,
+  op: Schema.Literals(["eq", "neq"]),
+  value: Schema.String,
+})
+
+const TextPrompt = Schema.Struct({
+  type: Schema.Literal("text"),
+  key: Schema.String,
+  message: Schema.String,
+  placeholder: optionalOmitUndefined(Schema.String),
+  when: optionalOmitUndefined(When),
+})
+
+const SelectOption = Schema.Struct({
+  label: Schema.String,
+  value: Schema.String,
+  hint: optionalOmitUndefined(Schema.String),
+})
+
+const SelectPrompt = Schema.Struct({
+  type: Schema.Literal("select"),
+  key: Schema.String,
+  message: Schema.String,
+  options: Schema.Array(SelectOption),
+  when: optionalOmitUndefined(When),
+})
+
+const Prompt = Schema.Union([TextPrompt, SelectPrompt])
+
+export class Method extends Schema.Class<Method>("ProviderAuthMethod")({
+  type: Schema.Literals(["oauth", "api"]),
+  label: Schema.String,
+  prompts: optionalOmitUndefined(Schema.Array(Prompt)),
+}) {}
+
+export const Methods = Schema.Record(Schema.String, Schema.Array(Method))
+export type Methods = typeof Methods.Type
+
+export class Authorization extends Schema.Class<Authorization>("ProviderAuthAuthorization")({
+  url: Schema.String,
+  method: Schema.Literals(["auto", "code"]),
+  instructions: Schema.String,
+}) {}
+
+export const AuthorizeInput = Schema.Struct({
+  method: Schema.Finite.annotate({ description: "Auth method index" }),
+  inputs: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({ description: "Prompt inputs" }),
+})
+export type AuthorizeInput = Schema.Schema.Type<typeof AuthorizeInput>
+
+export const CallbackInput = Schema.Struct({
+  method: Schema.Finite.annotate({ description: "Auth method index" }),
+  code: Schema.optional(Schema.String).annotate({ description: "OAuth authorization code" }),
+})
+export type CallbackInput = Schema.Schema.Type<typeof CallbackInput>
+
+export class OauthMissing extends Schema.TaggedErrorClass<OauthMissing>()("ProviderAuthOauthMissing", {
+  providerID: ProviderID,
+}) {}
+
+export class OauthCodeMissing extends Schema.TaggedErrorClass<OauthCodeMissing>()("ProviderAuthOauthCodeMissing", {
+  providerID: ProviderID,
+}) {}
+
+export class OauthCallbackFailed extends Schema.TaggedErrorClass<OauthCallbackFailed>()(
+  "ProviderAuthOauthCallbackFailed",
+  {},
+) {}
+
+export class ValidationFailed extends Schema.TaggedErrorClass<ValidationFailed>()("ProviderAuthValidationFailed", {
+  field: Schema.String,
+  message: Schema.String,
+}) {}
+
+export type Error = Auth.AuthError | OauthMissing | OauthCodeMissing | OauthCallbackFailed | ValidationFailed
+
+type Hook = NonNullable<Hooks["auth"]>
+
+export interface Interface {
+  readonly methods: () => Effect.Effect<Methods>
+  readonly authorize: (
+    input: {
+      providerID: ProviderID
+    } & AuthorizeInput,
+  ) => Effect.Effect<Authorization | undefined, Error>
+  readonly callback: (input: { providerID: ProviderID } & CallbackInput) => Effect.Effect<void, Error>
+}
+
+interface State {
+  hooks: Record<ProviderID, Hook>
+  pending: Map<ProviderID, AuthOAuthResult>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ProviderAuth") {}
+
+export const layer: Layer.Layer<Service, never, Auth.Service | Plugin.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const auth = yield* Auth.Service
+    const plugin = yield* Plugin.Service
+    const state = yield* InstanceState.make<State>(
+      Effect.fn("ProviderAuth.state")(function* () {
+        const plugins = yield* plugin.list()
+        return {
+          hooks: Record.fromEntries(
+            Arr.filterMap(plugins, (x) =>
+              x.auth?.provider !== undefined
+                ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
+                : Result.failVoid,
+            ),
+          ),
+          pending: new Map<ProviderID, AuthOAuthResult>(),
+        }
+      }),
+    )
+
+    const decode = Schema.decodeUnknownSync(Methods)
+    const methods = Effect.fn("ProviderAuth.methods")(function* () {
+      const hooks = (yield* InstanceState.get(state)).hooks
+      return decode(
+        Record.map(hooks, (item) =>
+          item.methods.map((method) => ({
+            type: method.type,
+            label: method.label,
+            ...(method.prompts && {
+              prompts: method.prompts.map((prompt) => {
+                if (prompt.type === "select") {
+                  return {
+                    type: "select" as const,
+                    key: prompt.key,
+                    message: prompt.message,
+                    options: prompt.options,
+                    ...(prompt.when && { when: prompt.when }),
+                  }
+                }
+                return {
+                  type: "text" as const,
+                  key: prompt.key,
+                  message: prompt.message,
+                  ...(prompt.placeholder && { placeholder: prompt.placeholder }),
+                  ...(prompt.when && { when: prompt.when }),
+                }
+              }),
+            }),
+          })),
+        ),
+      )
+    })
+
+    const authorize = Effect.fn("ProviderAuth.authorize")(function* (
+      input: { providerID: ProviderID } & AuthorizeInput,
+    ) {
+      const { hooks, pending } = yield* InstanceState.get(state)
+      const method = hooks[input.providerID].methods[input.method]
+      if (method.type !== "oauth") return
+
+      if (method.prompts && input.inputs) {
+        for (const prompt of method.prompts) {
+          if (prompt.type === "text" && prompt.validate && input.inputs[prompt.key] !== undefined) {
+            const error = prompt.validate(input.inputs[prompt.key])
+            if (error) return yield* new ValidationFailed({ field: prompt.key, message: error })
+          }
+        }
+      }
+
+      const result = yield* Effect.promise(() => method.authorize(input.inputs))
+      pending.set(input.providerID, result)
+      return {
+        url: result.url,
+        method: result.method,
+        instructions: result.instructions,
+      }
+    })
+
+    const callback = Effect.fn("ProviderAuth.callback")(function* (input: { providerID: ProviderID } & CallbackInput) {
+      const pending = (yield* InstanceState.get(state)).pending
+      const match = pending.get(input.providerID)
+      if (!match) return yield* new OauthMissing({ providerID: input.providerID })
+      if (match.method === "code" && !input.code) {
+        return yield* new OauthCodeMissing({ providerID: input.providerID })
+      }
+
+      const result = yield* Effect.promise(() =>
+        match.method === "code" ? match.callback(input.code!) : match.callback(),
+      )
+      if (!result || result.type !== "success") return yield* new OauthCallbackFailed({})
+
+      if ("key" in result) {
+        yield* auth.set(input.providerID, {
+          type: "api",
+          key: result.key,
+          ...(result.metadata ? { metadata: result.metadata } : {}),
+        })
+      }
+
+      if ("refresh" in result) {
+        const { type: _, provider: __, refresh, access, expires, ...extra } = result
+        yield* auth.set(input.providerID, {
+          type: "oauth",
+          access,
+          refresh,
+          expires,
+          ...extra,
+        })
+      }
+    })
+
+    return Service.of({ methods, authorize, callback })
+  }),
+)
+
+export const defaultLayer = Layer.suspend(() =>
+  layer.pipe(Layer.provide(Auth.defaultLayer), Layer.provide(Plugin.defaultLayer)),
+)
+
+export * as ProviderAuth from "./auth"