@miaws/miaw 1.18.5 → 1.18.6

package/src/account/repo.ts

@@ -1,173 +0,0 @@
-import { LayerNode } from "@miaw/core/effect/layer-node"
-import { eq } from "drizzle-orm"
-import { serviceUse } from "@miaw/core/effect/service-use"
-import { Effect, Layer, Option, Schema, Context } from "effect"
-
-import { Database } from "@miaw/core/database/database"
-import { AccountStateTable, AccountTable } from "@miaw/core/account/sql"
-import { AccessToken, AccountID, AccountRepoError, Info, OrgID, RefreshToken } from "./schema"
-import { normalizeServerUrl } from "./url"
-
-export type AccountRow = (typeof AccountTable)["$inferSelect"]
-
-const ACCOUNT_STATE_ID = 1
-
-export interface Interface {
-  readonly active: () => Effect.Effect<Option.Option<Info>, AccountRepoError>
-  readonly list: () => Effect.Effect<Info[], AccountRepoError>
-  readonly remove: (accountID: AccountID) => Effect.Effect<void, AccountRepoError>
-  readonly use: (accountID: AccountID, orgID: Option.Option<OrgID>) => Effect.Effect<void, AccountRepoError>
-  readonly getRow: (accountID: AccountID) => Effect.Effect<Option.Option<AccountRow>, AccountRepoError>
-  readonly persistToken: (input: {
-    accountID: AccountID
-    accessToken: AccessToken
-    refreshToken: RefreshToken
-    expiry: Option.Option<number>
-  }) => Effect.Effect<void, AccountRepoError>
-  readonly persistAccount: (input: {
-    id: AccountID
-    email: string
-    url: string
-    accessToken: AccessToken
-    refreshToken: RefreshToken
-    expiry: number
-    orgID: Option.Option<OrgID>
-  }) => Effect.Effect<void, AccountRepoError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@miaw/AccountRepo") {}
-
-export const use = serviceUse(Service)
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const { db } = yield* Database.Service
-    const decode = Schema.decodeUnknownSync(Info)
-
-    const query = <A, E>(effect: Effect.Effect<A, E>) =>
-      effect.pipe(Effect.mapError((cause) => new AccountRepoError({ message: "Database operation failed", cause })))
-
-    const current = Effect.fnUntraced(function* () {
-      const state = yield* db.select().from(AccountStateTable).where(eq(AccountStateTable.id, ACCOUNT_STATE_ID)).get()
-      if (!state?.active_account_id) return
-      const account = yield* db.select().from(AccountTable).where(eq(AccountTable.id, state.active_account_id)).get()
-      if (!account) return
-      return { ...account, active_org_id: state.active_org_id ?? null }
-    })
-
-    const state = (accountID: AccountID, orgID: Option.Option<OrgID>) => {
-      const id = Option.getOrNull(orgID)
-      return db
-        .insert(AccountStateTable)
-        .values({ id: ACCOUNT_STATE_ID, active_account_id: accountID, active_org_id: id })
-        .onConflictDoUpdate({
-          target: AccountStateTable.id,
-          set: { active_account_id: accountID, active_org_id: id },
-        })
-        .run()
-    }
-
-    const active = Effect.fn("AccountRepo.active")(() =>
-      query(current()).pipe(Effect.map((row) => (row ? Option.some(decode(row)) : Option.none()))),
-    )
-
-    const list = Effect.fn("AccountRepo.list")(() =>
-      query(
-        db
-          .select()
-          .from(AccountTable)
-          .all()
-          .pipe(Effect.map((rows) => rows.map((row: AccountRow) => decode({ ...row, active_org_id: null })))),
-      ),
-    )
-
-    const remove = Effect.fn("AccountRepo.remove")((accountID: AccountID) =>
-      query(
-        db.transaction((tx) =>
-          Effect.gen(function* () {
-            yield* tx
-              .update(AccountStateTable)
-              .set({ active_account_id: null, active_org_id: null })
-              .where(eq(AccountStateTable.active_account_id, accountID))
-              .run()
-            yield* tx.delete(AccountTable).where(eq(AccountTable.id, accountID)).run()
-          }),
-        ),
-      ).pipe(Effect.asVoid),
-    )
-
-    const use = Effect.fn("AccountRepo.use")((accountID: AccountID, orgID: Option.Option<OrgID>) =>
-      query(state(accountID, orgID)).pipe(Effect.asVoid),
-    )
-
-    const getRow = Effect.fn("AccountRepo.getRow")((accountID: AccountID) =>
-      query(db.select().from(AccountTable).where(eq(AccountTable.id, accountID)).get()).pipe(
-        Effect.map(Option.fromNullishOr),
-      ),
-    )
-
-    const persistToken = Effect.fn("AccountRepo.persistToken")((input) =>
-      query(
-        db
-          .update(AccountTable)
-          .set({
-            access_token: input.accessToken,
-            refresh_token: input.refreshToken,
-            token_expiry: Option.getOrNull(input.expiry),
-          })
-          .where(eq(AccountTable.id, input.accountID))
-          .run(),
-      ).pipe(Effect.asVoid),
-    )
-
-    const persistAccount = Effect.fn("AccountRepo.persistAccount")((input) =>
-      query(
-        db.transaction((tx) =>
-          Effect.gen(function* () {
-            const url = normalizeServerUrl(input.url)
-
-            yield* tx
-              .insert(AccountTable)
-              .values({
-                id: input.id,
-                email: input.email,
-                url,
-                access_token: input.accessToken,
-                refresh_token: input.refreshToken,
-                token_expiry: input.expiry,
-              })
-              .onConflictDoUpdate({
-                target: AccountTable.id,
-                set: {
-                  email: input.email,
-                  url,
-                  access_token: input.accessToken,
-                  refresh_token: input.refreshToken,
-                  token_expiry: input.expiry,
-                },
-              })
-              .run()
-            yield* state(input.id, input.orgID)
-          }),
-        ),
-      ).pipe(Effect.asVoid),
-    )
-
-    return Service.of({
-      active,
-      list,
-      remove,
-      use,
-      getRow,
-      persistToken,
-      persistAccount,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer))
-
-export const node = LayerNode.make(layer, [Database.node])
-
-export * as AccountRepo from "./repo"

package/src/account/schema.ts

@@ -1,99 +0,0 @@
-import { Schema } from "effect"
-import type * as HttpClientError from "effect/unstable/http/HttpClientError"
-
-export const AccountID = Schema.String.pipe(Schema.brand("AccountID"))
-export type AccountID = Schema.Schema.Type<typeof AccountID>
-
-export const OrgID = Schema.String.pipe(Schema.brand("OrgID"))
-export type OrgID = Schema.Schema.Type<typeof OrgID>
-
-export const AccessToken = Schema.String.pipe(Schema.brand("AccessToken"))
-export type AccessToken = Schema.Schema.Type<typeof AccessToken>
-
-export const RefreshToken = Schema.String.pipe(Schema.brand("RefreshToken"))
-export type RefreshToken = Schema.Schema.Type<typeof RefreshToken>
-
-export const DeviceCode = Schema.String.pipe(Schema.brand("DeviceCode"))
-export type DeviceCode = Schema.Schema.Type<typeof DeviceCode>
-
-export const UserCode = Schema.String.pipe(Schema.brand("UserCode"))
-export type UserCode = Schema.Schema.Type<typeof UserCode>
-
-export class Info extends Schema.Class<Info>("Account")({
-  id: AccountID,
-  email: Schema.String,
-  url: Schema.String,
-  active_org_id: Schema.NullOr(OrgID),
-}) {}
-
-export class Org extends Schema.Class<Org>("Org")({
-  id: OrgID,
-  name: Schema.String,
-}) {}
-
-export class AccountRepoError extends Schema.TaggedErrorClass<AccountRepoError>()("AccountRepoError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export class AccountServiceError extends Schema.TaggedErrorClass<AccountServiceError>()("AccountServiceError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-export class AccountTransportError extends Schema.TaggedErrorClass<AccountTransportError>()("AccountTransportError", {
-  method: Schema.String,
-  url: Schema.String,
-  description: Schema.optional(Schema.String),
-  cause: Schema.optional(Schema.Defect),
-}) {
-  static fromHttpClientError(error: HttpClientError.TransportError): AccountTransportError {
-    return new AccountTransportError({
-      method: error.request.method,
-      url: error.request.url,
-      description: error.description,
-      cause: error.cause,
-    })
-  }
-
-  override get message(): string {
-    return [
-      `Could not reach ${this.method} ${this.url}.`,
-      `This failed before the server returned an HTTP response.`,
-      this.description,
-      `Check your network, proxy, or VPN configuration and try again.`,
-    ]
-      .filter(Boolean)
-      .join("\n")
-  }
-}
-
-export type AccountError = AccountRepoError | AccountServiceError | AccountTransportError
-
-export class Login extends Schema.Class<Login>("Login")({
-  code: DeviceCode,
-  user: UserCode,
-  url: Schema.String,
-  server: Schema.String,
-  expiry: Schema.Duration,
-  interval: Schema.Duration,
-}) {}
-
-export class PollSuccess extends Schema.TaggedClass<PollSuccess>()("PollSuccess", {
-  email: Schema.String,
-}) {}
-
-export class PollPending extends Schema.TaggedClass<PollPending>()("PollPending", {}) {}
-
-export class PollSlow extends Schema.TaggedClass<PollSlow>()("PollSlow", {}) {}
-
-export class PollExpired extends Schema.TaggedClass<PollExpired>()("PollExpired", {}) {}
-
-export class PollDenied extends Schema.TaggedClass<PollDenied>()("PollDenied", {}) {}
-
-export class PollError extends Schema.TaggedClass<PollError>()("PollError", {
-  cause: Schema.Defect,
-}) {}
-
-export const PollResult = Schema.Union([PollSuccess, PollPending, PollSlow, PollExpired, PollDenied, PollError])
-export type PollResult = Schema.Schema.Type<typeof PollResult>

package/src/account/url.ts

@@ -1,8 +0,0 @@
-export const normalizeServerUrl = (input: string): string => {
-  const url = new URL(input)
-  url.search = ""
-  url.hash = ""
-
-  const pathname = url.pathname.replace(/\/+$/, "")
-  return pathname.length === 0 ? url.origin : `${url.origin}${pathname}`
-}

package/src/acp/agent.ts

@@ -1,95 +0,0 @@
-import {
-  RequestError,
-  type Agent as ACPAgent,
-  type AgentSideConnection,
-  type AuthenticateRequest,
-  type CancelNotification,
-  type CloseSessionRequest,
-  type ForkSessionRequest,
-  type InitializeRequest,
-  type ListSessionsRequest,
-  type LoadSessionRequest,
-  type NewSessionRequest,
-  type PromptRequest,
-  type ResumeSessionRequest,
-  type SetSessionConfigOptionRequest,
-  type SetSessionModelRequest,
-  type SetSessionModeRequest,
-} from "@agentclientprotocol/sdk"
-import { Effect } from "effect"
-import type { MiawClient } from "@miaw/sdk/v2"
-import * as ACPError from "./error"
-import * as ACPService from "./service"
-
-export function init({ sdk: _sdk }: { sdk: MiawClient }) {
-  return {
-    create: (connection: AgentSideConnection) => {
-      return new Agent(ACPService.make({ sdk: _sdk, connection }))
-    },
-  }
-}
-
-export class Agent implements ACPAgent {
-  constructor(private readonly service: ACPService.Interface) {}
-
-  initialize(params: InitializeRequest) {
-    return run(this.service.initialize(params))
-  }
-
-  authenticate(params: AuthenticateRequest) {
-    return run(this.service.authenticate(params))
-  }
-
-  newSession(params: NewSessionRequest) {
-    return run(this.service.newSession(params))
-  }
-
-  loadSession(params: LoadSessionRequest) {
-    return run(this.service.loadSession(params))
-  }
-
-  listSessions(params: ListSessionsRequest) {
-    return run(this.service.listSessions(params))
-  }
-
-  resumeSession(params: ResumeSessionRequest) {
-    return run(this.service.resumeSession(params))
-  }
-
-  closeSession(params: CloseSessionRequest) {
-    return run(this.service.closeSession(params))
-  }
-
-  unstable_forkSession(params: ForkSessionRequest) {
-    return run(this.service.forkSession(params))
-  }
-
-  setSessionConfigOption(params: SetSessionConfigOptionRequest) {
-    return run(this.service.setSessionConfigOption(params))
-  }
-
-  setSessionMode(params: SetSessionModeRequest) {
-    return run(this.service.setSessionMode(params))
-  }
-
-  unstable_setSessionModel(params: SetSessionModelRequest) {
-    return run(this.service.setSessionModel(params))
-  }
-
-  prompt(params: PromptRequest) {
-    return run(this.service.prompt(params))
-  }
-
-  cancel(params: CancelNotification) {
-    return run(this.service.cancel(params))
-  }
-}
-
-function run<A>(effect: Effect.Effect<A, ACPService.Error>) {
-  return Effect.runPromise(effect.pipe(Effect.mapError(ACPError.toRequestError))).catch((defect: unknown) => {
-    if (defect instanceof RequestError) throw defect
-    throw ACPError.toRequestError(ACPError.fromUnknownDefect(defect))
-  })
-}
-
-export * as ACP from "./agent"

package/src/acp/config-option.ts

@@ -1,203 +0,0 @@
-import type { SessionConfigOption } from "@agentclientprotocol/sdk"
-
-export const DEFAULT_VARIANT_VALUE = "default"
-
-export type ConfigOptionModel = {
-  id: string
-  name: string
-  variants?: Record<string, Record<string, unknown>>
-}
-
-export type ConfigOptionProvider = {
-  id: string
-  name: string
-  models: Record<string, ConfigOptionModel>
-}
-
-export type ConfigOptionMode = {
-  id: string
-  name: string
-  description?: string
-}
-
-export type ModelSelection = {
-  model: {
-    providerID: string
-    modelID: string
-  }
-  variant?: string
-}
-
-export function buildModelSelectOption(input: {
-  providers: readonly ConfigOptionProvider[]
-  currentModel: ModelSelection["model"]
-  currentVariant?: string
-  includeVariants?: boolean
-}): SessionConfigOption {
-  return {
-    id: "model",
-    name: "Model",
-    category: "model",
-    type: "select",
-    currentValue: formatCurrentModelId({
-      model: input.currentModel,
-      variant: input.currentVariant,
-      variants: variantsForModel(input.providers, input.currentModel),
-      includeVariant: input.includeVariants ?? false,
-    }),
-    options: buildModelSelectOptions(input.providers, { includeVariants: input.includeVariants ?? false }),
-  }
-}
-
-export function buildEffortSelectOption(input: {
-  variants: readonly string[]
-  currentVariant?: string
-}): SessionConfigOption | undefined {
-  if (input.variants.length === 0) return undefined
-
-  return {
-    id: "effort",
-    name: "Effort",
-    description: "Available effort levels for this model",
-    category: "thought_level",
-    type: "select",
-    currentValue: selectVariant(input.currentVariant, input.variants),
-    options: input.variants.map((variant) => ({
-      value: variant,
-      name: formatVariantName(variant),
-    })),
-  }
-}
-
-export function buildModeSelectOption(input: {
-  modes: readonly ConfigOptionMode[]
-  currentModeId: string
-}): SessionConfigOption {
-  return {
-    id: "mode",
-    name: "Session Mode",
-    category: "mode",
-    type: "select",
-    currentValue: input.currentModeId,
-    options: input.modes.map((mode) => ({
-      value: mode.id,
-      name: mode.name,
-      ...(mode.description ? { description: mode.description } : {}),
-    })),
-  }
-}
-
-export function buildConfigOptions(input: {
-  providers: readonly ConfigOptionProvider[]
-  currentModel: ModelSelection["model"]
-  currentVariant?: string
-  includeModelVariants?: boolean
-  modes?: readonly ConfigOptionMode[]
-  currentModeId?: string
-}): SessionConfigOption[] {
-  const variants = variantsForModel(input.providers, input.currentModel)
-  const effort = buildEffortSelectOption({ variants, currentVariant: input.currentVariant })
-
-  return [
-    buildModelSelectOption({
-      providers: input.providers,
-      currentModel: input.currentModel,
-      currentVariant: input.currentVariant,
-      includeVariants: input.includeModelVariants ?? false,
-    }),
-    ...(effort ? [effort] : []),
-    ...(input.modes && input.currentModeId
-      ? [buildModeSelectOption({ modes: input.modes, currentModeId: input.currentModeId })]
-      : []),
-  ]
-}
-
-export function parseModelSelection(modelId: string, providers: readonly ConfigOptionProvider[]): ModelSelection {
-  const provider = providers.find((item) => modelId.startsWith(`${item.id}/`))
-  if (provider) {
-    const modelID = modelId.slice(provider.id.length + 1)
-    if (provider.models[modelID]) {
-      return { model: { providerID: provider.id, modelID } }
-    }
-
-    const separator = modelID.lastIndexOf("/")
-    if (separator > -1) {
-      const baseModelID = modelID.slice(0, separator)
-      const variant = modelID.slice(separator + 1)
-      if (provider.models[baseModelID]?.variants?.[variant]) {
-        return { model: { providerID: provider.id, modelID: baseModelID }, variant }
-      }
-    }
-
-    return { model: { providerID: provider.id, modelID } }
-  }
-
-  const separator = modelId.indexOf("/")
-  if (separator === -1) {
-    return { model: { providerID: modelId, modelID: "" } }
-  }
-
-  return {
-    model: {
-      providerID: modelId.slice(0, separator),
-      modelID: modelId.slice(separator + 1),
-    },
-  }
-}
-
-export function formatCurrentModelId(input: {
-  model: ModelSelection["model"]
-  variant?: string
-  variants?: readonly string[]
-  includeVariant?: boolean
-}) {
-  const base = `${input.model.providerID}/${input.model.modelID}`
-  if (!input.includeVariant || !input.variants?.length) return base
-  return `${base}/${selectVariant(input.variant, input.variants)}`
-}
-
-export function formatVariantName(variant: string) {
-  return variant
-    .split(/[_-]/)
-    .map((part) => (part ? part.charAt(0).toUpperCase() + part.slice(1) : part))
-    .join(" ")
-}
-
-function buildModelSelectOptions(
-  providers: readonly ConfigOptionProvider[],
-  options: { includeVariants: boolean },
-): Array<{ value: string; name: string }> {
-  return providers.flatMap((provider) =>
-    Object.values(provider.models)
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .flatMap((model) => {
-        const base = {
-          value: `${provider.id}/${model.id}`,
-          name: `${provider.name}/${model.name}`,
-        }
-        if (!options.includeVariants || !model.variants) return [base]
-
-        return [
-          base,
-          ...Object.keys(model.variants)
-            .filter((variant) => variant !== DEFAULT_VARIANT_VALUE)
-            .map((variant) => ({
-              value: `${provider.id}/${model.id}/${variant}`,
-              name: `${provider.name}/${model.name} (${formatVariantName(variant)})`,
-            })),
-        ]
-      }),
-  )
-}
-
-function variantsForModel(providers: readonly ConfigOptionProvider[], model: ModelSelection["model"]) {
-  return Object.keys(
-    providers.find((provider) => provider.id === model.providerID)?.models[model.modelID]?.variants ?? {},
-  )
-}
-
-function selectVariant(variant: string | undefined, variants: readonly string[]) {
-  if (variant && variants.includes(variant)) return variant
-  if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE
-  return variants[0]
-}