opencode/packages/core/test/fixture/policy.ts

import { Config } from "@opencode/core/config"
import { ConfigIntegration } from "@opencode/core/config/integration"
import { ConfigPolicyPlugin } from "@opencode/core/config/plugin/policy"
import { Integration } from "@opencode/core/integration"
import { Mcp } from "@opencode/core/mcp/index"
import { Skill } from "@opencode/core/skill"
import { Info } from "@opencode/schema/config"
import { ConfigPolicy } from "@opencode/schema/config/policy"
import { ID } from "@opencode/schema/event"
import { Credential } from "@opencode/core/credential"
import { WebSearch } from "@opencode/core/websearch"
import { Effect, Schema, Stream } from "effect"
import { host } from "../plugin/host"

/** A connected organization's policy as the OpenCode Console delivers it: an integration config document. */
export function organizationPolicy(policies: ConfigPolicy.Info[], organization?: string) {
  return new ConfigIntegration.Document({
    type: "document",
    integrationID: Integration.ID.make("opencode"),
    connection: { type: "env", name: "OPENCODE_API_KEY" },
    organization,
    info: Schema.decodeUnknownSync(Info)({ policies }),
  })
}

/** Replaces the connected organization's policy, or removes it; publish `Event.Updated` to make plugins reload. */
export const setOrganizationPolicy = Effect.fn(function* (policies: ConfigPolicy.Info[] | undefined) {
  const config = yield* Config.Service
  yield* config.integration?.(Integration.ID.make("opencode"), policies && organizationPolicy(policies)) ?? Effect.void
})

// Exercise the real policy plugin against supplied catalogs without unrelated provider/permission setup.
export const registerIntegrationPolicy = Effect.fn(function* (input: {
  mcp?: Mcp.Interface
  skill?: Skill.Interface
  events?: Stream.Stream<{ readonly type: string }, unknown>
}) {
  yield* ConfigPolicyPlugin.Plugin.effect(
    host({
      event: {
        subscribe: () =>
          (input.events ?? Stream.never).pipe(
            Stream.filter((event) => event.type === "config.updated"),
            Stream.map(() => ({ id: ID.create(), created: Date.now(), type: "config.updated" as const, data: {} })),
          ),
      },
      provider: {
        list: () => Effect.die("unused provider.list"),
        get: () => Effect.die("unused provider.get"),
        transform: () => Effect.succeed({ dispose: Effect.void }),
        reload: () => Effect.void,
      },
      mcp: {
        list: () => Effect.die("unused mcp.list"),
        transform: (callback) => input.mcp?.transform(callback) ?? Effect.succeed({ dispose: Effect.void }),
        reload: () => input.mcp?.reload() ?? Effect.void,
      },
      skill: {
        list: () => Effect.die("unused skill.list"),
        transform: (callback) => input.skill?.transform(callback) ?? Effect.succeed({ dispose: Effect.void }),
        reload: () => input.skill?.reload() ?? Effect.void,
      },
      permission: {
        hook: () => Effect.succeed({ dispose: Effect.void }),
        list: () => Effect.die("unused permission.list"),
        get: () => Effect.die("unused permission.get"),
        reply: () => Effect.die("unused permission.reply"),
        assert: () => Effect.die("unused permission.assert"),
      },
    }),
  ).pipe(
    Effect.provideService(
      Credential.Service,
      Credential.Service.of({
        all: () => Effect.succeed([]),
        list: () => Effect.succeed([]),
        get: () => Effect.succeed(undefined),
        lock: () => Effect.die("unused Credential.lock"),
        create: () => Effect.die("unused Credential.create"),
        activate: () => Effect.die("unused Credential.activate"),
        update: () => Effect.die("unused Credential.update"),
        remove: () => Effect.die("unused Credential.remove"),
      }),
    ),
    Effect.provideService(
      WebSearch.Service,
      WebSearch.Service.of({
        providers: () => Effect.die("unused WebSearch.providers"),
        default: () => Effect.die("unused WebSearch.default"),
        select: () => Effect.die("unused WebSearch.select"),
        query: () => Effect.die("unused WebSearch.query"),
        transform: () => Effect.succeed({ dispose: Effect.void }),
        reload: () => Effect.void,
      }),
    ),
  )
})