woozlit 2.3.0 → 2.3.2

package/src/auth/index.ts

@@ -1,106 +0,0 @@
-import path from "path"
-import { Effect, Layer, Record, Result, Schema, Context } from "effect"
-import { zod } from "@/util/effect-zod"
-import { Global } from "../global"
-import { AppFileSystem } from "@woozlit/shared/filesystem"
-
-export const OAUTH_DUMMY_KEY = "WOOZLIT_CODE-oauth-dummy-key"
-
-const file = path.join(Global.Path.data, "auth.json")
-
-const fail = (message: string) => (cause: unknown) => new AuthError({ message, cause })
-
-export class Oauth extends Schema.Class<Oauth>("OAuth")({
-  type: Schema.Literal("oauth"),
-  refresh: Schema.String,
-  access: Schema.String,
-  expires: Schema.Number,
-  accountId: Schema.optional(Schema.String),
-  enterpriseUrl: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-
-export class Api extends Schema.Class<Api>("ApiAuth")({
-  type: Schema.Literal("api"),
-  key: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-}) {}
-
-export class WellKnown extends Schema.Class<WellKnown>("WellKnownAuth")({
-  type: Schema.Literal("wellknown"),
-  key: Schema.String,
-  token: Schema.String,
-}) {}
-
-const _Info = Schema.Union([Oauth, Api, WellKnown]).annotate({ discriminator: "type", identifier: "Auth" })
-export const Info = Object.assign(_Info, { zod: zod(_Info) })
-export type Info = Schema.Schema.Type<typeof _Info>
-
-export class AuthError extends Schema.TaggedErrorClass<AuthError>()("AuthError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export interface Interface {
-  readonly get: (providerID: string) => Effect.Effect<Info | undefined, AuthError>
-  readonly all: () => Effect.Effect<Record<string, Info>, AuthError>
-  readonly set: (key: string, info: Info) => Effect.Effect<void, AuthError>
-  readonly remove: (key: string) => Effect.Effect<void, AuthError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Auth") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* AppFileSystem.Service
-    const decode = Schema.decodeUnknownOption(Info)
-
-    const all = Effect.fn("Auth.all")(function* () {
-      if (process.env.WOOZLIT_CODE_AUTH_CONTENT) {
-        try {
-          return JSON.parse(process.env.WOOZLIT_CODE_AUTH_CONTENT)
-        } catch (err) {}
-      }
-
-      const data = (yield* fsys.readJson(file).pipe(Effect.orElseSucceed(() => ({})))) as Record<string, unknown>
-      return Record.filterMap(data, (value) => Result.fromOption(decode(value), () => undefined))
-    })
-
-    const get = Effect.fn("Auth.get")(function* (providerID: string) {
-      return (yield* all())[providerID]
-    })
-
-    const set = Effect.fn("Auth.set")(function* (key: string, info: Info) {
-      const norm = key.replace(/\/+$/, "")
-      const data = yield* all()
-      if (norm !== key) delete data[key]
-      delete data[norm + "/"]
-      const nextData = { ...data, [norm]: info }
-      if (process.env.WOOZLIT_CODE_AUTH_CONTENT) {
-        process.env.WOOZLIT_CODE_AUTH_CONTENT = JSON.stringify(nextData)
-      }
-      yield* fsys
-        .writeJson(file, nextData, 0o600)
-        .pipe(Effect.mapError(fail("Failed to write auth data")))
-    })
-
-    const remove = Effect.fn("Auth.remove")(function* (key: string) {
-      const norm = key.replace(/\/+$/, "")
-      const data = yield* all()
-      delete data[key]
-      delete data[norm]
-      if (process.env.WOOZLIT_CODE_AUTH_CONTENT) {
-        process.env.WOOZLIT_CODE_AUTH_CONTENT = JSON.stringify(data)
-      }
-      yield* fsys.writeJson(file, data, 0o600).pipe(Effect.mapError(fail("Failed to write auth data")))
-    })
-
-    return Service.of({ get, all, set, remove })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer))
-
-export * as Auth from "."

package/src/bus/bus-event.ts

@@ -1,33 +0,0 @@
-import z from "zod"
-import type { ZodType } from "zod"
-
-export type Definition = ReturnType<typeof define>
-
-const registry = new Map<string, Definition>()
-
-export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
-  const result = {
-    type,
-    properties,
-  }
-  registry.set(type, result)
-  return result
-}
-
-export function payloads() {
-  return registry
-    .entries()
-    .map(([type, def]) => {
-      return z
-        .object({
-          type: z.literal(type),
-          properties: def.properties,
-        })
-        .meta({
-          ref: `Event.${def.type}`,
-        })
-    })
-    .toArray()
-}
-
-export * as BusEvent from "./bus-event"

package/src/bus/global.ts

@@ -1,12 +0,0 @@
-import { EventEmitter } from "events"
-
-export type GlobalEvent = {
-  directory?: string
-  project?: string
-  workspace?: string
-  payload: any
-}
-
-export const GlobalBus = new EventEmitter<{
-  event: [GlobalEvent]
-}>()

package/src/bus/index.ts

@@ -1,193 +0,0 @@
-import z from "zod"
-import { Effect, Exit, Layer, PubSub, Scope, Context, Stream } from "effect"
-import { EffectBridge } from "@/effect"
-import { Log } from "../util"
-import { BusEvent } from "./bus-event"
-import { GlobalBus } from "./global"
-import { InstanceState } from "@/effect"
-import { makeRuntime } from "@/effect/run-service"
-
-const log = Log.create({ service: "bus" })
-
-export const InstanceDisposed = BusEvent.define(
-  "server.instance.disposed",
-  z.object({
-    directory: z.string(),
-  }),
-)
-
-type Payload<D extends BusEvent.Definition = BusEvent.Definition> = {
-  type: D["type"]
-  properties: z.infer<D["properties"]>
-}
-
-type State = {
-  wildcard: PubSub.PubSub<Payload>
-  typed: Map<string, PubSub.PubSub<Payload>>
-}
-
-export interface Interface {
-  readonly publish: <D extends BusEvent.Definition>(
-    def: D,
-    properties: z.output<D["properties"]>,
-  ) => Effect.Effect<void>
-  readonly subscribe: <D extends BusEvent.Definition>(def: D) => Stream.Stream<Payload<D>>
-  readonly subscribeAll: () => Stream.Stream<Payload>
-  readonly subscribeCallback: <D extends BusEvent.Definition>(
-    def: D,
-    callback: (event: Payload<D>) => unknown,
-  ) => Effect.Effect<() => void>
-  readonly subscribeAllCallback: (callback: (event: any) => unknown) => Effect.Effect<() => void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Bus") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Bus.state")(function* (ctx) {
-        const wildcard = yield* PubSub.unbounded<Payload>()
-        const typed = new Map<string, PubSub.PubSub<Payload>>()
-
-        yield* Effect.addFinalizer(() =>
-          Effect.gen(function* () {
-            // Publish InstanceDisposed before shutting down so subscribers see it
-            yield* PubSub.publish(wildcard, {
-              type: InstanceDisposed.type,
-              properties: { directory: ctx.directory },
-            })
-            yield* PubSub.shutdown(wildcard)
-            for (const ps of typed.values()) {
-              yield* PubSub.shutdown(ps)
-            }
-          }),
-        )
-
-        return { wildcard, typed }
-      }),
-    )
-
-    function getOrCreate<D extends BusEvent.Definition>(state: State, def: D) {
-      return Effect.gen(function* () {
-        let ps = state.typed.get(def.type)
-        if (!ps) {
-          ps = yield* PubSub.unbounded<Payload>()
-          state.typed.set(def.type, ps)
-        }
-        return ps as unknown as PubSub.PubSub<Payload<D>>
-      })
-    }
-
-    function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
-      return Effect.gen(function* () {
-        const s = yield* InstanceState.get(state)
-        const payload: Payload = { type: def.type, properties }
-        log.info("publishing", { type: def.type })
-
-        const ps = s.typed.get(def.type)
-        if (ps) yield* PubSub.publish(ps, payload)
-        yield* PubSub.publish(s.wildcard, payload)
-
-        const dir = yield* InstanceState.directory
-        const context = yield* InstanceState.context
-        const workspace = yield* InstanceState.workspaceID
-
-        GlobalBus.emit("event", {
-          directory: dir,
-          project: context.project.id,
-          workspace,
-          payload,
-        })
-      })
-    }
-
-    function subscribe<D extends BusEvent.Definition>(def: D): Stream.Stream<Payload<D>> {
-      log.info("subscribing", { type: def.type })
-      return Stream.unwrap(
-        Effect.gen(function* () {
-          const s = yield* InstanceState.get(state)
-          const ps = yield* getOrCreate(s, def)
-          return Stream.fromPubSub(ps)
-        }),
-      ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: def.type }))))
-    }
-
-    function subscribeAll(): Stream.Stream<Payload> {
-      log.info("subscribing", { type: "*" })
-      return Stream.unwrap(
-        Effect.gen(function* () {
-          const s = yield* InstanceState.get(state)
-          return Stream.fromPubSub(s.wildcard)
-        }),
-      ).pipe(Stream.ensuring(Effect.sync(() => log.info("unsubscribing", { type: "*" }))))
-    }
-
-    function on<T>(pubsub: PubSub.PubSub<T>, type: string, callback: (event: T) => unknown) {
-      return Effect.gen(function* () {
-        log.info("subscribing", { type })
-        const bridge = yield* EffectBridge.make()
-        const scope = yield* Scope.make()
-        const subscription = yield* Scope.provide(scope)(PubSub.subscribe(pubsub))
-
-        yield* Scope.provide(scope)(
-          Stream.fromSubscription(subscription).pipe(
-            Stream.runForEach((msg) =>
-              Effect.tryPromise({
-                try: () => Promise.resolve().then(() => callback(msg)),
-                catch: (cause) => {
-                  log.error("subscriber failed", { type, cause })
-                },
-              }).pipe(Effect.ignore),
-            ),
-            Effect.forkScoped,
-          ),
-        )
-
-        return () => {
-          log.info("unsubscribing", { type })
-          bridge.fork(Scope.close(scope, Exit.void))
-        }
-      })
-    }
-
-    const subscribeCallback = Effect.fn("Bus.subscribeCallback")(function* <D extends BusEvent.Definition>(
-      def: D,
-      callback: (event: Payload<D>) => unknown,
-    ) {
-      const s = yield* InstanceState.get(state)
-      const ps = yield* getOrCreate(s, def)
-      return yield* on(ps, def.type, callback)
-    })
-
-    const subscribeAllCallback = Effect.fn("Bus.subscribeAllCallback")(function* (callback: (event: any) => unknown) {
-      const s = yield* InstanceState.get(state)
-      return yield* on(s.wildcard, "*", callback)
-    })
-
-    return Service.of({ publish, subscribe, subscribeAll, subscribeCallback, subscribeAllCallback })
-  }),
-)
-
-export const defaultLayer = layer
-
-const { runPromise, runSync } = makeRuntime(Service, layer)
-
-// runSync is safe here because the subscribe chain (InstanceState.get, PubSub.subscribe,
-// Scope.make, Effect.forkScoped) is entirely synchronous. If any step becomes async, this will throw.
-export async function publish<D extends BusEvent.Definition>(def: D, properties: z.output<D["properties"]>) {
-  return runPromise((svc) => svc.publish(def, properties))
-}
-
-export function subscribe<D extends BusEvent.Definition>(
-  def: D,
-  callback: (event: { type: D["type"]; properties: z.infer<D["properties"]> }) => unknown,
-) {
-  return runSync((svc) => svc.subscribeCallback(def, callback))
-}
-
-export function subscribeAll(callback: (event: any) => unknown) {
-  return runSync((svc) => svc.subscribeAllCallback(callback))
-}
-
-export * as Bus from "."

package/src/cli/bootstrap.ts

@@ -1,33 +0,0 @@
-import { AppRuntime } from "@/effect/app-runtime"
-import { InstanceBootstrap } from "../project/bootstrap"
-import { Instance } from "../project/instance"
-import { SessionCheckpoint } from "@/session/checkpoint"
-import { Log } from "@/util"
-
-const log = Log.create({ service: "cli.bootstrap" })
-
-export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
-  return Instance.provide({
-    directory,
-    init: () => AppRuntime.runPromise(InstanceBootstrap),
-    fn: async () => {
-      try {
-        return await cb()
-      } finally {
-        // Give detached background checkpoint writers a chance to finish
-        // before teardown. Headless `mimo run` would otherwise exit right
-        // after the main response, killing any forked writer mid-LLM-call
-        // and leaving zero checkpoint files on disk.
-        //
-        // Up to 120s for ALL pending writers collectively. Writers that
-        // don't settle in time are abandoned — the runtime teardown will
-        // kill them anyway, and their thresholds stay marked so the next
-        // process invocation can observe the gap via fireCheckpoints.
-        await AppRuntime.runPromise(
-          SessionCheckpoint.Service.use((svc) => svc.drainWriters()),
-        ).catch((err) => log.warn("checkpoint drain failed", { error: String(err) }))
-        await Instance.dispose()
-      }
-    },
-  })
-}

package/src/cli/cmd/account.ts

@@ -1,258 +0,0 @@
-import { cmd } from "./cmd"
-import { Duration, Effect, Match, Option } from "effect"
-import { UI } from "../ui"
-import { Account } from "@/account/account"
-import { AccountID, OrgID, PollExpired, type PollResult, type AccountError } from "@/account/schema"
-import { AppRuntime } from "@/effect/app-runtime"
-import * as Prompt from "../effect/prompt"
-import open from "open"
-
-const openBrowser = (url: string) => Effect.promise(() => open(url).catch(() => undefined))
-
-const println = (msg: string) => Effect.sync(() => UI.println(msg))
-
-const dim = (value: string) => UI.Style.TEXT_DIM + value + UI.Style.TEXT_NORMAL
-
-const activeSuffix = (isActive: boolean) => (isActive ? dim(" (active)") : "")
-
-export const formatAccountLabel = (account: { email: string; url: string }, isActive: boolean) =>
-  `${account.email} ${dim(account.url)}${activeSuffix(isActive)}`
-
-const formatOrgChoiceLabel = (account: { email: string }, org: { name: string }, isActive: boolean) =>
-  `${org.name} (${account.email})${activeSuffix(isActive)}`
-
-export const formatOrgLine = (
-  account: { email: string; url: string },
-  org: { id: string; name: string },
-  isActive: boolean,
-) => {
-  const dot = isActive ? UI.Style.TEXT_SUCCESS + "●" + UI.Style.TEXT_NORMAL : " "
-  const name = isActive ? UI.Style.TEXT_HIGHLIGHT_BOLD + org.name + UI.Style.TEXT_NORMAL : org.name
-  return `  ${dot} ${name}  ${dim(account.email)}  ${dim(account.url)}  ${dim(org.id)}`
-}
-
-const isActiveOrgChoice = (
-  active: Option.Option<{ id: AccountID; active_org_id: OrgID | null }>,
-  choice: { accountID: AccountID; orgID: OrgID },
-) => Option.isSome(active) && active.value.id === choice.accountID && active.value.active_org_id === choice.orgID
-
-const loginEffect = Effect.fn("login")(function* (url: string) {
-  const service = yield* Account.Service
-
-  yield* Prompt.intro("Log in")
-  const login = yield* service.login(url)
-
-  yield* Prompt.log.info("Go to: " + login.url)
-  yield* Prompt.log.info("Enter code: " + login.user)
-  yield* openBrowser(login.url)
-
-  const s = Prompt.spinner()
-  yield* s.start("Waiting for authorization...")
-
-  const poll = (wait: Duration.Duration): Effect.Effect<PollResult, AccountError> =>
-    Effect.gen(function* () {
-      yield* Effect.sleep(wait)
-      const result = yield* service.poll(login)
-      if (result._tag === "PollPending") return yield* poll(wait)
-      if (result._tag === "PollSlow") return yield* poll(Duration.sum(wait, Duration.seconds(5)))
-      return result
-    })
-
-  const result = yield* poll(login.interval).pipe(
-    Effect.timeout(login.expiry),
-    Effect.catchTag("TimeoutError", () => Effect.succeed(new PollExpired())),
-  )
-
-  yield* Match.valueTags(result, {
-    PollSuccess: (r) =>
-      Effect.gen(function* () {
-        yield* s.stop("Logged in as " + r.email)
-        yield* Prompt.outro("Done")
-      }),
-    PollExpired: () => s.stop("Device code expired", 1),
-    PollDenied: () => s.stop("Authorization denied", 1),
-    PollError: (r) => s.stop("Error: " + String(r.cause), 1),
-    PollPending: () => s.stop("Unexpected state", 1),
-    PollSlow: () => s.stop("Unexpected state", 1),
-  })
-})
-
-const logoutEffect = Effect.fn("logout")(function* (email?: string) {
-  const service = yield* Account.Service
-  const accounts = yield* service.list()
-  if (accounts.length === 0) return yield* println("Not logged in")
-
-  if (email) {
-    const match = accounts.find((a) => a.email === email)
-    if (!match) return yield* println("Account not found: " + email)
-    yield* service.remove(match.id)
-    yield* Prompt.outro("Logged out from " + email)
-    return
-  }
-
-  const active = yield* service.active()
-  const activeID = Option.map(active, (a) => a.id)
-
-  yield* Prompt.intro("Log out")
-
-  const opts = accounts.map((a) => {
-    const isActive = Option.isSome(activeID) && activeID.value === a.id
-    return {
-      value: a,
-      label: formatAccountLabel(a, isActive),
-    }
-  })
-
-  const selected = yield* Prompt.select({ message: "Select account to log out", options: opts })
-  if (Option.isNone(selected)) return
-
-  yield* service.remove(selected.value.id)
-  yield* Prompt.outro("Logged out from " + selected.value.email)
-})
-
-interface OrgChoice {
-  orgID: OrgID
-  accountID: AccountID
-  label: string
-}
-
-const switchEffect = Effect.fn("switch")(function* () {
-  const service = yield* Account.Service
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("Not logged in")
-
-  const active = yield* service.active()
-
-  const opts = groups.flatMap((group) =>
-    group.orgs.map((org) => {
-      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
-      return {
-        value: { orgID: org.id, accountID: group.account.id, label: org.name },
-        label: formatOrgChoiceLabel(group.account, org, isActive),
-      }
-    }),
-  )
-  if (opts.length === 0) return yield* println("No orgs found")
-
-  yield* Prompt.intro("Switch org")
-
-  const selected = yield* Prompt.select<OrgChoice>({ message: "Select org", options: opts })
-  if (Option.isNone(selected)) return
-
-  const choice = selected.value
-  yield* service.use(choice.accountID, Option.some(choice.orgID))
-  yield* Prompt.outro("Switched to " + choice.label)
-})
-
-const orgsEffect = Effect.fn("orgs")(function* () {
-  const service = yield* Account.Service
-
-  const groups = yield* service.orgsByAccount()
-  if (groups.length === 0) return yield* println("No accounts found")
-  if (!groups.some((group) => group.orgs.length > 0)) return yield* println("No orgs found")
-
-  const active = yield* service.active()
-
-  for (const group of groups) {
-    for (const org of group.orgs) {
-      const isActive = isActiveOrgChoice(active, { accountID: group.account.id, orgID: org.id })
-      yield* println(formatOrgLine(group.account, org, isActive))
-    }
-  }
-})
-
-const openEffect = Effect.fn("open")(function* () {
-  const service = yield* Account.Service
-  const active = yield* service.active()
-  if (Option.isNone(active)) return yield* println("No active account")
-
-  const url = active.value.url
-  yield* openBrowser(url)
-  yield* Prompt.outro("Opened " + url)
-})
-
-export const LoginCommand = cmd({
-  command: "login <url>",
-  describe: false,
-  builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "server URL",
-      type: "string",
-      demandOption: true,
-    }),
-  async handler(args) {
-    UI.empty()
-    await AppRuntime.runPromise(loginEffect(args.url))
-  },
-})
-
-export const LogoutCommand = cmd({
-  command: "logout [email]",
-  describe: false,
-  builder: (yargs) =>
-    yargs.positional("email", {
-      describe: "account email to log out from",
-      type: "string",
-    }),
-  async handler(args) {
-    UI.empty()
-    await AppRuntime.runPromise(logoutEffect(args.email))
-  },
-})
-
-export const SwitchCommand = cmd({
-  command: "switch",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await AppRuntime.runPromise(switchEffect())
-  },
-})
-
-export const OrgsCommand = cmd({
-  command: "orgs",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await AppRuntime.runPromise(orgsEffect())
-  },
-})
-
-export const OpenCommand = cmd({
-  command: "open",
-  describe: false,
-  async handler() {
-    UI.empty()
-    await AppRuntime.runPromise(openEffect())
-  },
-})
-
-export const ConsoleCommand = cmd({
-  command: "console",
-  describe: false,
-  builder: (yargs) =>
-    yargs
-      .command({
-        ...LoginCommand,
-        describe: "log in to console",
-      })
-      .command({
-        ...LogoutCommand,
-        describe: "log out from console",
-      })
-      .command({
-        ...SwitchCommand,
-        describe: "switch active org",
-      })
-      .command({
-        ...OrgsCommand,
-        describe: "list orgs",
-      })
-      .command({
-        ...OpenCommand,
-        describe: "open active console account",
-      })
-      .demandCommand(),
-  async handler() {},
-})