anymous 1.3.0 → 1.3.2

package/src/audio.d.ts

@@ -1,14 +0,0 @@
-declare module "*.wav" {
-  const file: string
-  export default file
-}
-
-declare module "*.mp3" {
-  const file: string
-  export default file
-}
-
-declare module "*.wasm" {
-  const file: string
-  export default file
-}

package/src/auth/index.ts

@@ -1,97 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import path from "path"
-import { Effect, Layer, Record, Result, Schema, Context } from "effect"
-import { NonNegativeInt } from "@anymous-ai/core/schema"
-import { Global } from "@anymous-ai/core/global"
-import { FSUtil } from "@anymous-ai/core/fs-util"
-
-export const OAUTH_DUMMY_KEY = "anymous-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: NonNegativeInt,
-  accountId: Schema.optional(Schema.String),
-  enterpriseUrl: Schema.optional(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,
-}) {}
-
-export const Info = Schema.Union([Oauth, Api, WellKnown]).annotate({ discriminator: "type", identifier: "Auth" })
-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>()("@anymous/Auth") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* FSUtil.Service
-    const decode = Schema.decodeUnknownOption(Info)
-
-    const all = Effect.fn("Auth.all")(function* () {
-      if (process.env.ANYMOUS_AUTH_CONTENT) {
-        try {
-          return JSON.parse(process.env.ANYMOUS_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 + "/"]
-      yield* fsys
-        .writeJson(file, { ...data, [norm]: info }, 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]
-      yield* fsys.writeJson(file, data, 0o600).pipe(Effect.mapError(fail("Failed to write auth data")))
-    })
-
-    return Service.of({ get, all, set, remove })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [FSUtil.node] })
-
-export * as Auth from "."

package/src/background/job.ts

@@ -1,37 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { BackgroundJob as CoreBackgroundJob } from "@anymous-ai/core/background-job"
-import { InstanceState } from "@/effect/instance-state"
-import { Effect, Layer } from "effect"
-
-export {
-  Service,
-  type ExtendInput,
-  type Info,
-  type Interface,
-  type StartInput,
-  type Status,
-  type WaitInput,
-  type WaitResult,
-} from "@anymous-ai/core/background-job"
-
-/** Keeps the legacy service instance-scoped while sharing the core registry engine. */
-const layer = Layer.effect(
-  CoreBackgroundJob.Service,
-  Effect.gen(function* () {
-    const state = yield* InstanceState.make(() => CoreBackgroundJob.make)
-    return CoreBackgroundJob.Service.of({
-      list: () => InstanceState.useEffect(state, (jobs) => jobs.list()),
-      get: (id) => InstanceState.useEffect(state, (jobs) => jobs.get(id)),
-      start: (input) => InstanceState.useEffect(state, (jobs) => jobs.start(input)),
-      extend: (input) => InstanceState.useEffect(state, (jobs) => jobs.extend(input)),
-      wait: (input) => InstanceState.useEffect(state, (jobs) => jobs.wait(input)),
-      waitForPromotion: (id) => InstanceState.useEffect(state, (jobs) => jobs.waitForPromotion(id)),
-      promote: (id) => InstanceState.useEffect(state, (jobs) => jobs.promote(id)),
-      cancel: (id) => InstanceState.useEffect(state, (jobs) => jobs.cancel(id)),
-    })
-  }),
-)
-
-export const node = LayerNode.make({ service: CoreBackgroundJob.Service, layer, deps: [] })
-
-export * as BackgroundJob from "./job"

package/src/bus/global.ts

@@ -1,22 +0,0 @@
-import { EventEmitter } from "events"
-import { Identifier } from "@/id/id"
-
-export type GlobalEvent = {
-  directory?: string
-  project?: string
-  workspace?: string
-  payload: any
-}
-
-class GlobalBusEmitter extends EventEmitter<{
-  event: [GlobalEvent]
-}> {
-  override emit(eventName: "event", event: GlobalEvent): boolean {
-    if (event.payload && typeof event.payload === "object" && !("id" in event.payload)) {
-      event.payload.id = event.payload.syncEvent?.id ?? Identifier.create("evt", "ascending")
-    }
-    return super.emit(eventName, event)
-  }
-}
-
-export const GlobalBus = new GlobalBusEmitter()

package/src/cli/bootstrap.ts

@@ -1,11 +0,0 @@
-import { InstanceRuntime } from "../project/instance-runtime"
-import { context } from "../project/instance-context"
-
-export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
-  const ctx = await InstanceRuntime.load({ directory })
-  try {
-    return await context.provide(ctx, cb)
-  } finally {
-    await InstanceRuntime.disposeInstance(ctx)
-  }
-}

package/src/cli/cmd/account.ts

@@ -1,265 +0,0 @@
-import { cmd } from "./cmd"
-import { Duration, Effect, Match, Option } from "effect"
-import { UI } from "../ui"
-import { Account } from "@/account/account"
-import type { AccountID, OrgID } from "@/account/schema"
-import { PollExpired, type PollResult, type AccountError } from "@/account/schema"
-import { effectCmd } from "../effect-cmd"
-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 defaultConsoleUrl = "https://anymous-cli.vercel.app"
-
-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 = effectCmd({
-  command: "login [url]",
-  describe: false,
-  instance: false,
-  builder: (yargs) =>
-    yargs.positional("url", {
-      describe: "server URL",
-      type: "string",
-    }),
-  handler: Effect.fn("Cli.account.login")(function* (args) {
-    UI.empty()
-    yield* Effect.orDie(loginEffect(args.url ?? defaultConsoleUrl))
-  }),
-})
-
-export const LogoutCommand = effectCmd({
-  command: "logout [email]",
-  describe: false,
-  instance: false,
-  builder: (yargs) =>
-    yargs.positional("email", {
-      describe: "account email to log out from",
-      type: "string",
-    }),
-  handler: Effect.fn("Cli.account.logout")(function* (args) {
-    UI.empty()
-    yield* Effect.orDie(logoutEffect(args.email))
-  }),
-})
-
-export const SwitchCommand = effectCmd({
-  command: "switch",
-  describe: false,
-  instance: false,
-  handler: Effect.fn("Cli.account.switch")(function* () {
-    UI.empty()
-    yield* Effect.orDie(switchEffect())
-  }),
-})
-
-export const OrgsCommand = effectCmd({
-  command: "orgs",
-  describe: false,
-  instance: false,
-  handler: Effect.fn("Cli.account.orgs")(function* () {
-    UI.empty()
-    yield* Effect.orDie(orgsEffect())
-  }),
-})
-
-export const OpenCommand = effectCmd({
-  command: "open",
-  describe: false,
-  instance: false,
-  handler: Effect.fn("Cli.account.open")(function* () {
-    UI.empty()
-    yield* Effect.orDie(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() {},
-})

package/src/cli/cmd/acp.ts

@@ -1,73 +0,0 @@
-import { Effect } from "effect"
-import { effectCmd } from "../effect-cmd"
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
-import { ServerAuth } from "@/server/auth"
-import { createanymousClient } from "@anymous-ai/sdk/v2"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-import { ACPProfile } from "@/acp/profile"
-
-export const AcpCommand = effectCmd({
-  command: "acp",
-  describe: "start ACP (Agent Client Protocol) server",
-  builder: (yargs) => {
-    return withNetworkOptions(yargs).option("cwd", {
-      describe: "working directory",
-      type: "string",
-      default: process.cwd(),
-    })
-  },
-  handler: Effect.fn("Cli.acp")(function* (args) {
-    const { Server } = yield* Effect.promise(() => import("@/server/server"))
-    const { ACP } = yield* Effect.promise(() => import("@/acp/agent"))
-    ACPProfile.mark("cli.acp.handler")
-    process.env.ANYMOUS_CLIENT = "acp"
-    const opts = yield* resolveNetworkOptions(args)
-    const server = yield* Effect.promise(() => ACPProfile.measure("cli.acp.server.listen", () => Server.listen(opts)))
-
-    const sdk = createanymousClient({
-      baseUrl: `http://${server.hostname}:${server.port}`,
-      headers: ServerAuth.headers(),
-    })
-
-    const input = new WritableStream<Uint8Array>({
-      write(chunk) {
-        return new Promise<void>((resolve, reject) => {
-          process.stdout.write(chunk, (err) => {
-            if (err) {
-              reject(err)
-            } else {
-              resolve()
-            }
-          })
-        })
-      },
-    })
-    const output = new ReadableStream<Uint8Array>({
-      start(controller) {
-        process.stdin.on("data", (chunk: Buffer) => {
-          controller.enqueue(new Uint8Array(chunk))
-        })
-        process.stdin.on("end", () => controller.close())
-        process.stdin.on("error", (err) => controller.error(err))
-      },
-    })
-
-    const stream = ndJsonStream(input, output)
-    const agent = ACP.init({ sdk })
-
-    new AgentSideConnection((conn) => {
-      ACPProfile.mark("cli.acp.connection.create")
-      return agent.create(conn)
-    }, stream)
-
-    yield* Effect.logInfo("setup connection")
-    process.stdin.resume()
-    yield* Effect.promise(
-      () =>
-        new Promise<void>((resolve, reject) => {
-          process.stdin.on("end", () => resolve())
-          process.stdin.on("error", reject)
-        }),
-    )
-  }),
-})