onlycode 1.18.0 → 1.19.0

package/src/markdown.d.ts

@@ -1,4 +0,0 @@
-declare module "*.md" {
-  const content: string
-  export default content
-}

package/src/mcp/auth.ts

@@ -1,174 +0,0 @@
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import path from "path"
-import { serviceUse } from "@opencode-ai/core/effect/service-use"
-import { Global } from "@opencode-ai/core/global"
-import { Effect, Layer, Context, Option, Schema } from "effect"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
-
-export const Tokens = Schema.Struct({
-  accessToken: Schema.mutableKey(Schema.String),
-  refreshToken: Schema.mutableKey(Schema.optional(Schema.String)),
-  expiresAt: Schema.mutableKey(Schema.optional(Schema.Number)),
-  scope: Schema.mutableKey(Schema.optional(Schema.String)),
-})
-export type Tokens = Schema.Schema.Type<typeof Tokens>
-
-export const ClientInfo = Schema.Struct({
-  clientId: Schema.mutableKey(Schema.String),
-  clientSecret: Schema.mutableKey(Schema.optional(Schema.String)),
-  clientIdIssuedAt: Schema.mutableKey(Schema.optional(Schema.Number)),
-  clientSecretExpiresAt: Schema.mutableKey(Schema.optional(Schema.Number)),
-})
-export type ClientInfo = Schema.Schema.Type<typeof ClientInfo>
-
-export const Entry = Schema.Struct({
-  tokens: Schema.mutableKey(Schema.optional(Tokens)),
-  clientInfo: Schema.mutableKey(Schema.optional(ClientInfo)),
-  codeVerifier: Schema.mutableKey(Schema.optional(Schema.String)),
-  oauthState: Schema.mutableKey(Schema.optional(Schema.String)),
-  serverUrl: Schema.mutableKey(Schema.optional(Schema.String)),
-})
-export type Entry = Schema.Schema.Type<typeof Entry>
-
-const decodeAuthData = Schema.decodeUnknownOption(Schema.Record(Schema.String, Entry))
-type AuthData = Record<string, Entry>
-
-const filepath = path.join(Global.Path.data, "mcp-auth.json")
-const lockKey = `mcp-auth:${filepath}`
-
-export interface Interface {
-  readonly all: () => Effect.Effect<Record<string, Entry>>
-  readonly get: (mcpName: string) => Effect.Effect<Entry | undefined>
-  readonly getForUrl: (mcpName: string, serverUrl: string) => Effect.Effect<Entry | undefined>
-  readonly set: (mcpName: string, entry: Entry, serverUrl?: string) => Effect.Effect<void>
-  readonly remove: (mcpName: string) => Effect.Effect<void>
-  readonly updateTokens: (mcpName: string, tokens: Tokens, serverUrl?: string) => Effect.Effect<void>
-  readonly updateClientInfo: (mcpName: string, clientInfo: ClientInfo, serverUrl?: string) => Effect.Effect<void>
-  readonly updateCodeVerifier: (mcpName: string, codeVerifier: string) => Effect.Effect<void>
-  readonly clearCodeVerifier: (mcpName: string) => Effect.Effect<void>
-  readonly updateOAuthState: (mcpName: string, oauthState: string) => Effect.Effect<void>
-  readonly getOAuthState: (mcpName: string) => Effect.Effect<string | undefined>
-  readonly clearOAuthState: (mcpName: string) => Effect.Effect<void>
-  readonly isTokenExpired: (mcpName: string) => Effect.Effect<boolean | null>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/McpAuth") {}
-
-export const use = serviceUse(Service)
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const flock = yield* EffectFlock.Service
-
-    const read = Effect.fn("McpAuth.read")(function* () {
-      return yield* fs.readJson(filepath).pipe(
-        Effect.map((data): AuthData => Option.getOrElse(decodeAuthData(data), () => ({}) as AuthData) as AuthData),
-        Effect.catch(() => Effect.succeed({} as AuthData)),
-      )
-    })
-
-    const all = Effect.fn("McpAuth.all")(function* () {
-      return yield* read().pipe(flock.withLock(lockKey), Effect.orDie)
-    })
-
-    const mutate = Effect.fn("McpAuth.mutate")(function* (update: (data: AuthData) => AuthData | undefined) {
-      yield* Effect.gen(function* () {
-        const next = update(yield* read())
-        if (!next) return
-        yield* fs.writeJson(filepath, next, 0o600).pipe(Effect.orDie)
-      }).pipe(flock.withLock(lockKey), Effect.orDie)
-    })
-
-    const get = Effect.fn("McpAuth.get")(function* (mcpName: string) {
-      const data = yield* all()
-      return data[mcpName]
-    })
-
-    const getForUrl = Effect.fn("McpAuth.getForUrl")(function* (mcpName: string, serverUrl: string) {
-      const entry = yield* get(mcpName)
-      if (!entry) return undefined
-      if (!entry.serverUrl) return undefined
-      if (entry.serverUrl !== serverUrl) return undefined
-      return entry
-    })
-
-    const set = Effect.fn("McpAuth.set")(function* (mcpName: string, entry: Entry, serverUrl?: string) {
-      yield* mutate((data) => ({
-        ...data,
-        [mcpName]: serverUrl ? { ...entry, serverUrl } : entry,
-      }))
-    })
-
-    const remove = Effect.fn("McpAuth.remove")(function* (mcpName: string) {
-      yield* mutate((data) => {
-        const next = { ...data }
-        delete next[mcpName]
-        return next
-      })
-    })
-
-    const updateField = <K extends keyof Entry>(field: K, spanName: string) =>
-      Effect.fn(`McpAuth.${spanName}`)(function* (mcpName: string, value: NonNullable<Entry[K]>, serverUrl?: string) {
-        yield* mutate((data) => {
-          const entry = data[mcpName] ?? {}
-          entry[field] = value
-          if (serverUrl) entry.serverUrl = serverUrl
-          return { ...data, [mcpName]: entry }
-        })
-      })
-
-    const clearField = (field: keyof Entry, spanName: string) =>
-      Effect.fn(`McpAuth.${spanName}`)(function* (mcpName: string) {
-        yield* mutate((data) => {
-          const entry = data[mcpName]
-          if (!entry) return undefined
-          delete entry[field]
-          return { ...data, [mcpName]: entry }
-        })
-      })
-
-    const updateTokens = updateField("tokens", "updateTokens")
-    const updateClientInfo = updateField("clientInfo", "updateClientInfo")
-    const updateCodeVerifier = updateField("codeVerifier", "updateCodeVerifier")
-    const updateOAuthState = updateField("oauthState", "updateOAuthState")
-    const clearCodeVerifier = clearField("codeVerifier", "clearCodeVerifier")
-    const clearOAuthState = clearField("oauthState", "clearOAuthState")
-
-    const getOAuthState = Effect.fn("McpAuth.getOAuthState")(function* (mcpName: string) {
-      const entry = yield* get(mcpName)
-      return entry?.oauthState
-    })
-
-    const isTokenExpired = Effect.fn("McpAuth.isTokenExpired")(function* (mcpName: string) {
-      const entry = yield* get(mcpName)
-      if (!entry?.tokens) return null
-      if (!entry.tokens.expiresAt) return false
-      return entry.tokens.expiresAt < Date.now() / 1000
-    })
-
-    return Service.of({
-      all,
-      get,
-      getForUrl,
-      set,
-      remove,
-      updateTokens,
-      updateClientInfo,
-      updateCodeVerifier,
-      clearCodeVerifier,
-      updateOAuthState,
-      getOAuthState,
-      clearOAuthState,
-      isTokenExpired,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(EffectFlock.defaultLayer), Layer.provide(FSUtil.defaultLayer))
-
-export const node = LayerNode.make(layer, [FSUtil.node, EffectFlock.node])
-
-export * as McpAuth from "./auth"

package/src/mcp/catalog.ts

@@ -1,153 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import {
-  CallToolResultSchema,
-  ListToolsResultSchema,
-  ToolSchema,
-  type Tool as MCPToolDef,
-} from "@modelcontextprotocol/sdk/types.js"
-import { dynamicTool, jsonSchema, type JSONSchema7, type Tool } from "ai"
-import { Effect } from "effect"
-
-const DEFAULT_TIMEOUT = 30_000
-const MAX_LIST_PAGES = 1_000
-
-const TolerantListToolsResultSchema = ListToolsResultSchema.extend({
-  tools: ToolSchema.omit({ outputSchema: true }).array(),
-})
-
-export async function paginate<T, R extends { nextCursor?: string }>(
-  list: (cursor?: string) => Promise<R>,
-  items: (result: R) => T[],
-) {
-  const result: T[] = []
-  const cursors = new Set<string>()
-  let cursor: string | undefined
-
-  for (let page = 0; page < MAX_LIST_PAGES; page++) {
-    const page = await list(cursor)
-    result.push(...items(page))
-    if (page.nextCursor === undefined) return result
-    if (cursors.has(page.nextCursor)) throw new Error(`MCP list returned duplicate cursor: ${page.nextCursor}`)
-    cursors.add(page.nextCursor)
-    cursor = page.nextCursor
-  }
-
-  throw new Error(`MCP list exceeded ${MAX_LIST_PAGES} pages`)
-}
-
-export function defs(client: Client, timeout?: number) {
-  return listTools(client, timeout ?? DEFAULT_TIMEOUT).pipe(Effect.catch(() => Effect.void))
-}
-
-export function convertTool(mcpTool: MCPToolDef, client: Client, timeout?: number): Tool {
-  const inputSchema: JSONSchema7 = {
-    ...(mcpTool.inputSchema as JSONSchema7),
-    type: "object",
-    properties: (mcpTool.inputSchema.properties ?? {}) as JSONSchema7["properties"],
-    additionalProperties: false,
-  }
-
-  return dynamicTool({
-    description: mcpTool.description ?? "",
-    inputSchema: jsonSchema(inputSchema),
-    execute: async (args: unknown, options) => {
-      const result = await client.callTool(
-        {
-          name: mcpTool.name,
-          arguments: (args || {}) as Record<string, unknown>,
-        },
-        CallToolResultSchema,
-        {
-          resetTimeoutOnProgress: true,
-          signal: options.abortSignal,
-          timeout,
-          // The MCP SDK only sends a progress token when this hook is present, enabling timeout resets.
-          onprogress: () => {},
-        },
-      )
-      if (result.isError)
-        throw new Error(
-          result.content
-            .flatMap((item) => (item.type === "text" ? [item.text] : []))
-            .filter((text) => text.trim())
-            .join("\n\n") || "MCP tool returned an error",
-        )
-      if (result.structuredContent === undefined || result.structuredContent === null) return result
-      return {
-        ...result,
-        content: [{ type: "text" as const, text: JSON.stringify(result.structuredContent) }],
-      }
-    },
-  })
-}
-
-export function fetch<T extends { name: string }>(
-  clientName: string,
-  client: Client,
-  list: (client: Client) => Promise<T[]>,
-  label: string,
-) {
-  return Effect.tryPromise({
-    try: () => list(client),
-    catch: (error) => error,
-  }).pipe(
-    Effect.tapError((error) =>
-      Effect.logWarning(`failed to get ${label}`, {
-        clientName,
-        error: error instanceof Error ? error.message : String(error),
-      }),
-    ),
-    Effect.map((items) => {
-      const sanitizedClient = sanitize(clientName)
-      return Object.fromEntries(
-        items.map((item) => [sanitizedClient + ":" + sanitize(item.name), { ...item, client: clientName }]),
-      )
-    }),
-    Effect.orElseSucceed(() => undefined),
-  )
-}
-
-export const sanitize = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, "_")
-
-export function prompts(client: Client, timeout?: number) {
-  if (!client.getServerCapabilities()?.prompts) return Promise.resolve([])
-  return paginate(
-    (cursor) => client.listPrompts(cursor === undefined ? undefined : { cursor }, { timeout }),
-    (result) => result.prompts,
-  )
-}
-
-export function resources(client: Client, timeout?: number) {
-  if (!client.getServerCapabilities()?.resources) return Promise.resolve([])
-  return paginate(
-    (cursor) => client.listResources(cursor === undefined ? undefined : { cursor }, { timeout }),
-    (result) => result.resources,
-  )
-}
-
-function listTools(client: Client, timeout: number) {
-  return Effect.tryPromise({
-    try: () =>
-      paginate(
-        async (cursor) => {
-          const params = cursor === undefined ? undefined : { cursor }
-          try {
-            return await client.listTools(params, { timeout })
-          } catch (error) {
-            if (!(error instanceof Error) || !isOutputSchemaValidationError(error)) throw error
-            return client.request({ method: "tools/list", params }, TolerantListToolsResultSchema, { timeout })
-          }
-        },
-        (result) => result.tools,
-      ),
-    catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-  })
-}
-
-function isOutputSchemaValidationError(error: Error) {
-  return /can't resolve reference|resolves to more than one schema|outputSchema|schema.*reference|reference.*schema/i.test(
-    error.message,
-  )
-}
-
-export * as McpCatalog from "./catalog"