ceos/opencode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(console): complete Go login readiness

Browse source
This commit is contained in:
vprdev 2026-08-03 12:19:31 -04:00
commit 92e5af4fa0
59 changed files with 3410 additions and 676 deletions
Download patch file Download diff file Expand all files Collapse all files

26
packages/core/src/integration.ts
View file

@ -404,6 +404,7 @@ const layer = Layer.effect(
.get()
.integrations.get(attempt.integrationID)
?.implementations.get(attempt.methodID)
const previous = (yield* credentials.list(attempt.integrationID)).at(-1)
const persistence = yield* Effect.sync(() => attempt.label ?? implementation?.label?.(exit.value)).pipe(
Effect.flatMap((label) =>
credentials.create({
@ -412,11 +413,26 @@ const layer = Layer.effect(
value: exit.value,
}),
),
Effect.asVoid,
Effect.exit,
)
const settled = Exit.isSuccess(persistence)
? yield* Effect.gen(function* () {
yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: attempt.integrationID })
yield* bus.publish(Integration.Event.Updated, {})
}).pipe(Effect.exit)
: persistence
if (Exit.isFailure(settled) && Exit.isSuccess(persistence)) {
yield* credentials.remove(persistence.value.id)
if (previous) {
yield* credentials.create({
integrationID: previous.integrationID,
label: previous.label,
value: previous.value,
})
}
}
const settledAt = yield* Clock.currentTimeMillis
const terminal: TerminalAttempt = Exit.isSuccess(persistence)
const terminal: TerminalAttempt = Exit.isSuccess(settled)
? {
status: "complete",
integrationID: attempt.integrationID,
@ -426,15 +442,13 @@ const layer = Layer.effect(
: {
status: "failed",
integrationID: attempt.integrationID,
message: message(persistence.cause),
message: message(settled.cause),
time: attempt.time,
removeAt: settledAt + terminalRetention,
}
// Persisting attempts cannot be cancelled, expired, or claimed again.
yield* SynchronizedRef.update(attempts, (current) => new Map(current).set(attemptID, terminal))
if (Exit.isFailure(persistence)) yield* Effect.failCause(persistence.cause)
yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: attempt.integrationID })
yield* bus.publish(Integration.Event.Updated, {})
if (Exit.isFailure(settled)) yield* Effect.failCause(settled.cause)
}).pipe(Effect.ensuring(close(attempt.scope)))
}),
)

52
packages/core/src/plugin/provider/opencode.ts
View file

@ -1,4 +1,4 @@
import { Duration, Effect, Schema, Semaphore, Stream } from "effect"
import { Duration, Effect, Option, Schema, Semaphore } from "effect"
import type { Scope } from "effect"
import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/effect/integration"
import { define } from "@opencode-ai/plugin/effect/plugin"
@ -47,15 +47,13 @@ function oauth(http: HttpClient.HttpClient) {
Effect.gen(function* () {
const server = yield* normalizeServer(inputs.server ?? defaultServer)
const device = yield* post(http, `${server}/auth/device/code`, { client_id: clientID }, Device)
const verification = URL.canParse(device.verification_uri_complete)
? new URL(device.verification_uri_complete)
: undefined
if (verification && verification.protocol !== "http:" && verification.protocol !== "https:") {
const verification = new URL(device.verification_uri_complete, new URL(server).origin)
if (verification.protocol !== "http:" && verification.protocol !== "https:") {
return yield* Effect.fail(new Error("Invalid device verification URL: expected HTTP(S)"))
}
return {
mode: "auto" as const,
url: verification?.href ?? `${server}/${device.verification_uri_complete.replace(/^\/+/, "")}`,
url: verification.href,
instructions: `Enter code: ${device.user_code}`,
callback: poll(http, server, device.device_code, Duration.seconds(device.interval)),
}
@ -97,13 +95,14 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
: undefined
connected = connection !== undefined
providers = credential
? yield* fetchProviders(http, credential).pipe(
Effect.catch((cause) =>
Effect.logWarning("failed to load OpenCode provider config", { cause }).pipe(Effect.as(undefined)),
),
)
: undefined
const managed = credential && typeof credential.metadata?.server === "string"
const loaded = managed ? yield* fetchProviders(http, credential) : undefined
if (managed && !loaded) {
return yield* Effect.fail(
new Error("OpenCode Console did not return provider config for the selected organization"),
)
}
providers = loaded
})
yield* ctx.integration.transform((draft) => {
@ -117,7 +116,7 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
})
})
yield* load()
yield* load().pipe(Effect.orDie)
yield* ctx.catalog.transform((catalog) => {
for (const [providerID, item] of Object.entries(providers ?? {})) {
catalog.provider.update(providerID, (provider) => {
@ -192,12 +191,19 @@ export const OpencodePlugin = define<HttpClient.HttpClient | Bus.Service | Scope
}
})
const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
Stream.filter((event) => event.data.integrationID === Integration.ID.make("opencode")),
Stream.runForEach(refresh),
Effect.forkScoped({ startImmediately: true }),
)
const unsubscribe = yield* bus.listen((event) => {
if (event.type !== Integration.Event.ConnectionUpdated.type) return Effect.void
const data = Schema.decodeUnknownOption(Integration.Event.ConnectionUpdated.data)(event.data)
if (Option.isNone(data) || data.value.integrationID !== Integration.ID.make("opencode")) return Effect.void
return loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload()))).pipe(
Effect.timeoutOrElse({
duration: "30 seconds",
orElse: () => Effect.fail(new Error("Timed out loading OpenCode Console provider config")),
}),
Effect.orDie,
)
})
yield* Effect.addFinalizer(() => unsubscribe)
}),
})
@ -334,12 +340,6 @@ function credential(http: HttpClient.HttpClient, server: string, token: typeof T
orgName: org.name,
},
})
const providers = yield* fetchProviders(http, value)
if (!providers) {
return yield* Effect.fail(
new Error("OpenCode Console did not return provider config for the selected organization"),
)
}
return value
})
}

63
packages/core/test/plugin/provider-opencode.test.ts
View file

@ -104,7 +104,7 @@ describe("OpencodePlugin", () => {
Response.json({
device_code: "device",
user_code: "user",
verification_uri_complete: "/verify",
verification_uri_complete: "/console/verify",
expires_in: 60,
interval: 60,
}),
@ -132,20 +132,58 @@ describe("OpencodePlugin", () => {
}),
)
it.effect("keeps an absolute verification URL", () =>
Effect.gen(function* () {
const http = HttpClient.make((request) =>
Effect.succeed(
HttpClientResponse.fromWeb(
request,
Response.json({
device_code: "device",
user_code: "user",
verification_uri_complete: "https://login.example.com/device/verify",
expires_in: 60,
interval: 60,
}),
),
),
)
const plugin = yield* Plugin.Service
const host = yield* PluginHost.make(plugin)
const bus = yield* Bus.Service
const integration = yield* Integration.Service
yield* OpencodePlugin.effect(host).pipe(
Effect.provideService(Bus.Service, bus),
Effect.provideService(Integration.Service, integration),
Effect.provideService(HttpClient.HttpClient, http),
)
const attempt = yield* integration.oauth.connect({
integrationID: Integration.ID.make("opencode"),
methodID: Integration.MethodID.make("device"),
inputs: {},
})
yield* integration.oauth.cancel({ integrationID: Integration.ID.make("opencode"), attemptID: attempt.attemptID })
expect(attempt.url).toBe("https://login.example.com/device/verify")
}),
)
it.live("uses a canonical custom server throughout device authorization", () =>
Effect.acquireUseRelease(
Effect.sync(() => {
const requests: string[] = []
const requested = Promise.withResolvers<void>()
const release = Promise.withResolvers<void>()
const server = Bun.serve({
port: 0,
fetch: (request) => {
fetch: async (request) => {
const url = new URL(request.url)
requests.push(`${request.method} ${url.pathname}`)
if (url.pathname.endsWith("/auth/device/code")) {
return Response.json({
device_code: "device",
user_code: "user",
verification_uri_complete: `${url.origin}/verify`,
verification_uri_complete: "/console/verify",
expires_in: 60,
interval: 0,
})
@ -156,14 +194,16 @@ describe("OpencodePlugin", () => {
if (url.pathname.endsWith("/api/user")) return Response.json({ id: "user", email: "user@example.com" })
if (url.pathname.endsWith("/api/orgs")) return Response.json([{ id: "org", name: "Org" }])
if (url.pathname.endsWith("/api/config")) {
requested.resolve()
await release.promise
return Response.json({ config: { enterprise: { url: url.origin }, provider: {} } })
}
return new Response("Not found", { status: 404 })
},
})
return { requests, server }
return { release, requested, requests, server }
}),
({ requests, server }) =>
({ release, requested, requests, server }) =>
Effect.gen(function* () {
yield* addPlugin()
const integrations = yield* Integration.Service
@ -173,7 +213,12 @@ describe("OpencodePlugin", () => {
methodID: Integration.MethodID.make("device"),
inputs: { server: `${server.url.origin}/console///?ignored=true#ignored` },
})
expect(attempt.url).toBe(`${server.url.origin}/verify`)
expect(attempt.url).toBe(`${server.url.origin}/console/verify`)
yield* Effect.promise(() => requested.promise)
expect(yield* integrations.oauth.status({ integrationID, attemptID: attempt.attemptID })).toMatchObject({
status: "pending",
})
release.resolve()
yield* eventually(
integrations.oauth.status({ integrationID, attemptID: attempt.attemptID }),
(status) => status.status === "complete",
@ -188,7 +233,11 @@ describe("OpencodePlugin", () => {
metadata: { server: `${server.url.origin}/console`, orgID: "org", orgName: "Org" },
})
}),
({ server }) => Effect.promise(() => server.stop(true)),
({ release, server }) =>
Effect.promise(() => {
release.resolve()
return server.stop(true)
}),
),
)