anymous 1.2.7 → 1.3.1

package/src/cli/cmd/upgrade.ts

@@ -1,113 +0,0 @@
-import type { Argv } from "yargs"
-import { UI } from "../ui"
-import * as prompts from "@clack/prompts"
-import { Installation } from "../../installation"
-import { InstallationVersion } from "@anymous-ai/core/installation/version"
-
-const ANYMOUS_RELEASES = "https://api.github.com/repos/anymousdark/anymous-ai/releases/latest"
-
-async function checkanymousUpdate(): Promise<string | null> {
-  try {
-    const resp = await fetch(ANYMOUS_RELEASES, { headers: { "User-Agent": "anymous" } })
-    if (!resp.ok) return null
-    const data: any = await resp.json()
-    return (data.tag_name as string).replace(/^v/, "")
-  } catch {
-    return null
-  }
-}
-
-export const UpgradeCommand = {
-  command: "upgrade [target]",
-  describe: "upgrade Anymous to the latest or a specific version",
-  builder: (yargs: Argv) => {
-    return yargs
-      .positional("target", {
-        describe: "version to upgrade to, for ex '0.1.48' or 'v0.1.48'",
-        type: "string",
-      })
-      .option("method", {
-        alias: "m",
-        describe: "installation method to use",
-        type: "string",
-        choices: ["curl", "npm", "pnpm", "bun", "brew", "choco", "scoop"],
-      })
-      .option("sync", {
-        alias: "s",
-        describe: "sync with latest anymous release before upgrading",
-        type: "boolean",
-        default: false,
-      })
-  },
-  handler: async (args: { target?: string; method?: string; sync?: boolean }) => {
-    UI.empty()
-    UI.println(UI.logo("  "))
-    UI.empty()
-    prompts.intro("Upgrade")
-
-    // Check for anymous updates
-    const anymousLatest = await checkanymousUpdate()
-    if (anymousLatest && anymousLatest !== InstallationVersion) {
-      prompts.log.info(`anymous v${anymousLatest} disponível (atual: v${InstallationVersion})`)
-      if (args.sync) {
-        prompts.log.info("Sincronizando com anymous...")
-        prompts.log.info(`Execute: bun run script/sync-anymous.ts --version=${anymousLatest}`)
-      } else {
-        const sync = await prompts.confirm({
-          message: `Sincronizar com anymous v${anymousLatest}?`,
-          initialValue: false,
-        })
-        if (sync) {
-          prompts.log.info(`Execute para sincronizar:`)
-          prompts.log.info(`  bun run script/sync-anymous.ts --version=${anymousLatest}`)
-          prompts.log.info(`Depois: cd packages/anymous/dist-npm && npm publish --access public`)
-        }
-      }
-    }
-
-    const detectedMethod = await Installation.method()
-    const method = (args.method as Installation.Method) ?? detectedMethod
-    if (method === "unknown") {
-      prompts.log.error(`anymous is installed to ${process.execPath} and may be managed by a package manager`)
-      const install = await prompts.select({
-        message: "Install anyways?",
-        options: [
-          { label: "Yes", value: true },
-          { label: "No", value: false },
-        ],
-        initialValue: false,
-      })
-      if (!install) {
-        prompts.outro("Done")
-        return
-      }
-    }
-    prompts.log.info("Using method: " + method)
-    const target = args.target ? args.target.replace(/^v/, "") : await Installation.latest()
-
-    if (InstallationVersion === target) {
-      prompts.log.warn(`anymous upgrade skipped: ${target} is already installed`)
-      prompts.outro("Done")
-      return
-    }
-
-    prompts.log.info(`From ${InstallationVersion} → ${target}`)
-    const spinner = prompts.spinner()
-    spinner.start("Upgrading...")
-    const err = await Installation.upgrade(method, target).catch((err) => err)
-    if (err) {
-      spinner.stop("Upgrade failed", 1)
-      if (err instanceof Installation.UpgradeFailedError) {
-        if (method === "choco" && err.stderr.includes("not running from an elevated command shell")) {
-          prompts.log.error("Please run the terminal as Administrator and try again")
-        } else {
-          prompts.log.error(err.stderr)
-        }
-      } else if (err instanceof Error) prompts.log.error(err.message)
-      prompts.outro("Done")
-      return
-    }
-    spinner.stop("Upgrade complete")
-    prompts.outro("Done")
-  },
-}

package/src/cli/cmd/web.ts

@@ -1,84 +0,0 @@
-import { Effect } from "effect"
-import { UI } from "../ui"
-import { effectCmd } from "../effect-cmd"
-import { withNetworkOptions, resolveNetworkOptions } from "../network"
-import { Flag } from "@anymous-ai/core/flag/flag"
-import open from "open"
-import { networkInterfaces } from "os"
-
-function getNetworkIPs() {
-  const nets = networkInterfaces()
-  const results: string[] = []
-
-  for (const name of Object.keys(nets)) {
-    const net = nets[name]
-    if (!net) continue
-
-    for (const netInfo of net) {
-      // Skip internal and non-IPv4 addresses
-      if (netInfo.internal || netInfo.family !== "IPv4") continue
-
-      // Skip Docker bridge networks (typically 172.x.x.x)
-      if (netInfo.address.startsWith("172.")) continue
-
-      results.push(netInfo.address)
-    }
-  }
-
-  return results
-}
-
-export const WebCommand = effectCmd({
-  command: "web",
-  builder: (yargs) => withNetworkOptions(yargs),
-  describe: "start Anymous server and open web interface",
-  // Server loads instances per-request via x-anymous-directory header — no
-  // ambient project InstanceContext needed at startup.
-  instance: false,
-  handler: Effect.fn("Cli.web")(function* (args) {
-    const { Server } = yield* Effect.promise(() => import("../../server/server"))
-    if (!Flag.ANYMOUS_SERVER_PASSWORD) {
-      UI.println(UI.Style.TEXT_WARNING_BOLD + "!  ANYMOUS_SERVER_PASSWORD is not set; server is unsecured.")
-    }
-    const opts = yield* resolveNetworkOptions(args)
-    const server = yield* Effect.promise(() => Server.listen(opts))
-    UI.empty()
-    UI.println(UI.logo("  "))
-    UI.empty()
-
-    if (opts.hostname === "0.0.0.0") {
-      // Show localhost for local access
-      const localhostUrl = `http://localhost:${server.port}`
-      UI.println(UI.Style.TEXT_INFO_BOLD + "  Local access:      ", UI.Style.TEXT_NORMAL, localhostUrl)
-
-      // Show network IPs for remote access
-      const networkIPs = getNetworkIPs()
-      if (networkIPs.length > 0) {
-        for (const ip of networkIPs) {
-          UI.println(
-            UI.Style.TEXT_INFO_BOLD + "  Network access:    ",
-            UI.Style.TEXT_NORMAL,
-            `http://${ip}:${server.port}`,
-          )
-        }
-      }
-
-      if (opts.mdns) {
-        UI.println(
-          UI.Style.TEXT_INFO_BOLD + "  mDNS:              ",
-          UI.Style.TEXT_NORMAL,
-          `${opts.mdnsDomain}:${server.port}`,
-        )
-      }
-
-      // Open localhost in browser
-      open(localhostUrl).catch(() => {})
-    } else {
-      const displayUrl = server.url.toString()
-      UI.println(UI.Style.TEXT_INFO_BOLD + "  Web interface:    ", UI.Style.TEXT_NORMAL, displayUrl)
-      open(displayUrl).catch(() => {})
-    }
-
-    yield* Effect.never
-  }),
-})

package/src/cli/effect/prompt.ts

@@ -1,37 +0,0 @@
-import * as prompts from "@clack/prompts"
-import { Effect, Option } from "effect"
-
-export const intro = (msg: string) => Effect.sync(() => prompts.intro(msg))
-export const outro = (msg: string) => Effect.sync(() => prompts.outro(msg))
-
-export const log = {
-  info: (msg: string) => Effect.sync(() => prompts.log.info(msg)),
-  error: (msg: string) => Effect.sync(() => prompts.log.error(msg)),
-  warn: (msg: string) => Effect.sync(() => prompts.log.warn(msg)),
-  success: (msg: string) => Effect.sync(() => prompts.log.success(msg)),
-}
-
-const optional = <Value>(result: Value | symbol) => {
-  if (prompts.isCancel(result)) return Option.none<Value>()
-  return Option.some(result)
-}
-
-export const select = <Value>(opts: Parameters<typeof prompts.select<Value>>[0]) =>
-  Effect.promise(() => prompts.select(opts)).pipe(Effect.map((result) => optional(result)))
-
-export const autocomplete = <Value>(opts: Parameters<typeof prompts.autocomplete<Value>>[0]) =>
-  Effect.promise(() => prompts.autocomplete(opts)).pipe(Effect.map((result) => optional(result)))
-
-export const text = (opts: Parameters<typeof prompts.text>[0]) =>
-  Effect.promise(() => prompts.text(opts)).pipe(Effect.map((result) => optional(result)))
-
-export const password = (opts: Parameters<typeof prompts.password>[0]) =>
-  Effect.promise(() => prompts.password(opts)).pipe(Effect.map((result) => optional(result)))
-
-export const spinner = () => {
-  const s = prompts.spinner()
-  return {
-    start: (msg: string) => Effect.sync(() => s.start(msg)),
-    stop: (msg: string, code?: number) => Effect.sync(() => s.stop(msg, code)),
-  }
-}

package/src/cli/effect-cmd.ts

@@ -1,96 +0,0 @@
-import type { Argv } from "yargs"
-import { Effect, Schema } from "effect"
-import type { AppServices } from "@/effect/app-runtime"
-import type { InstanceStore } from "@/project/instance-store"
-import { cmd, type WithDoubleDash } from "./cmd/cmd"
-
-/**
- * User-visible command failure. Throw via `fail("...")` from an effectCmd handler
- * to surface a printed message + non-zero exit. Recognised by the global error
- * formatter in `src/cli/error.ts` (FormatError), so the existing top-level
- * catch + cleanup in `src/index.ts` runs normally.
- */
-export class CliError extends Schema.TaggedErrorClass<CliError>()("CliError", {
-  message: Schema.String,
-  exitCode: Schema.optional(Schema.Number),
-}) {}
-
-export const fail = (message: string, exitCode = 1) => Effect.fail(new CliError({ message, exitCode }))
-
-interface EffectCmdOpts<Args, A> {
-  command: string | readonly string[]
-  aliases?: string | readonly string[]
-  describe: string | false
-  builder?: (yargs: Argv) => Argv<Args>
-  /**
-   * Whether the command needs a project InstanceContext. Defaults to true.
-   *
-   * `true` (default): wraps the handler in `InstanceStore.Service.provide({directory})`
-   * so `InstanceRef` resolves to a loaded `InstanceContext`. Auto-disposes via
-   * `Effect.ensuring(store.dispose(ctx))` on every Exit (matches the legacy
-   * `bootstrap()` finally-disposal). Runs InstanceBootstrap (config + plugin
-   * init + LSP/File/etc forks) eagerly.
-   *
-   * `false`: skip the instance entirely. Saves the InstanceBootstrap work and
-   * suppresses the `server.instance.disposed` IPC event. The handler runs
-   * directly under AppRuntime — it can yield any `AppServices` but must not
-   * yield `InstanceRef` (it'd be undefined, causing a defect).
-   *
-   * Function form: `(args) => boolean` decides per-invocation. Useful for
-   * commands like `run --attach <url>` where one flag flips between local
-   * (needs instance) and remote (doesn't).
-   *
-   * Use `false` for commands that don't read project state (e.g. `models`,
-   * `serve`, `web`, `account`, `db`, `upgrade`).
-   */
-  instance?: boolean | ((args: Args) => boolean)
-  /** Defaults to process.cwd(). Override for commands that take a directory positional. */
-  directory?: (args: Args) => string
-  handler: (args: WithDoubleDash<Args>) => Effect.Effect<A, CliError, AppServices | InstanceStore.Service>
-}
-
-/**
- * Effect-native CLI command builder. Wraps yargs `cmd()` so the handler body is
- * an `Effect` with `InstanceRef` provided and any `AppServices` yieldable.
- *
- * The handler is wrapped in `Effect.ensuring(store.dispose(ctx))` so the loaded
- * InstanceContext is disposed (runDisposers + IPC `server.instance.disposed`)
- * on every Exit — success, typed failure, defect, or interruption. Matches the
- * legacy `bootstrap()` finally-disposal semantics without per-handler boilerplate.
- *
- * Errors propagate to the existing top-level handler in `src/index.ts`; use
- * `fail("...")` for user-visible domain failures (clean exit, formatted message).
- *
- * Handlers are typically `Effect.fn("Cli.<name>")(function*(args) { ... })`,
- * which adds a named tracing span per CLI invocation. Once all commands use
- * `effectCmd`, swapping the underlying `cmd()` factory for effect/cli's
- * `Command.make(...)` won't touch any handler bodies.
- */
-export const effectCmd = <Args, A>(opts: EffectCmdOpts<Args, A>) =>
-  cmd<{}, Args>({
-    command: opts.command,
-    aliases: opts.aliases,
-    describe: opts.describe,
-    builder: opts.builder as never,
-    async handler(rawArgs) {
-      const { AppRuntime } = await import("@/effect/app-runtime")
-      // yargs typing wraps Args in ArgumentsCamelCase<WithDoubleDash<...>>; cast at the boundary.
-      const args = rawArgs as unknown as WithDoubleDash<Args>
-      const useInstance = typeof opts.instance === "function" ? opts.instance(args) : opts.instance !== false
-      if (!useInstance) {
-        await AppRuntime.runPromise(opts.handler(args))
-        return
-      }
-      const { InstanceStore } = await import("@/project/instance-store")
-      const { InstanceRef } = await import("@/effect/instance-ref")
-      const directory = opts.directory?.(args) ?? process.cwd()
-      const { store, ctx } = await AppRuntime.runPromise(
-        InstanceStore.Service.use((store) => store.load({ directory }).pipe(Effect.map((ctx) => ({ store, ctx })))),
-      )
-      try {
-        await AppRuntime.runPromise(opts.handler(args).pipe(Effect.provideService(InstanceRef, ctx)))
-      } finally {
-        await AppRuntime.runPromise(store.dispose(ctx))
-      }
-    },
-  })

package/src/cli/error.ts

@@ -1,130 +0,0 @@
-import { NamedError } from "@anymous-ai/core/util/error"
-import { errorFormat } from "@/util/error"
-import { isRecord } from "@/util/record"
-
-type ConfigIssue = { message: string; path: string[] }
-
-function isTaggedError(error: unknown, tag: string): error is Record<string, unknown> {
-  return isRecord(error) && error._tag === tag
-}
-
-function configData(input: unknown, tag: string): Record<string, unknown> | undefined {
-  if (!isRecord(input)) return undefined
-  if (input.name === tag && isRecord(input.data)) return input.data
-  if (input._tag === tag) return input
-  return undefined
-}
-
-function stringField(input: Record<string, unknown>, key: string): string | undefined {
-  return typeof input[key] === "string" ? input[key] : undefined
-}
-
-function configIssues(input: Record<string, unknown>): ConfigIssue[] {
-  return Array.isArray(input.issues)
-    ? input.issues.filter((issue): issue is ConfigIssue => {
-        if (!isRecord(issue)) return false
-        return (
-          typeof issue.message === "string" &&
-          Array.isArray(issue.path) &&
-          issue.path.every((x) => typeof x === "string")
-        )
-      })
-    : []
-}
-
-export function FormatError(input: unknown): string | undefined {
-  if (input instanceof Error && isRecord(input.cause) && "body" in input.cause) {
-    const formatted = FormatError(input.cause.body)
-    if (formatted) return formatted
-  }
-
-  // CliError: domain failure surfaced from an effectCmd handler via fail("...")
-  if (isTaggedError(input, "CliError")) {
-    if (typeof input.exitCode === "number") process.exitCode = input.exitCode
-    return stringField(input, "message") ?? ""
-  }
-
-  // MCPFailed: { name: string }
-  if (NamedError.hasName(input, "MCPFailed")) {
-    const data = isRecord(input) && isRecord(input.data) ? stringField(input.data, "name") : undefined
-    return `MCP server "${data}" failed. Note, Anymous does not support MCP authentication yet.`
-  }
-
-  // AccountServiceError, AccountTransportError: TaggedErrorClass
-  if (isTaggedError(input, "AccountServiceError") || isTaggedError(input, "AccountTransportError")) {
-    return stringField(input, "message") ?? ""
-  }
-
-  // ProviderModelNotFoundError: { providerID: string, modelID: string, suggestions?: string[] }
-  const providerModelNotFound = configData(input, "ProviderModelNotFoundError")
-  if (providerModelNotFound) {
-    const suggestions = Array.isArray(providerModelNotFound.suggestions)
-      ? providerModelNotFound.suggestions.filter((x) => typeof x === "string")
-      : []
-    return [
-      `Model not found: ${stringField(providerModelNotFound, "providerID")}/${stringField(providerModelNotFound, "modelID")}`,
-      ...(suggestions.length ? ["Did you mean: " + suggestions.join(", ")] : []),
-      `Try: \`anymous models\` to list available models`,
-      `Or check your config (anymous.json) provider/model names`,
-    ].join("\n")
-  }
-
-  // ProviderInitError: { providerID: string }
-  const providerInit = configData(input, "ProviderInitError")
-  if (providerInit) {
-    return `Failed to initialize provider "${stringField(providerInit, "providerID")}". Check credentials and configuration.`
-  }
-
-  // ConfigJsonError: { path: string, message?: string }
-  const configJson = configData(input, "ConfigJsonError")
-  if (configJson) {
-    const message = stringField(configJson, "message")
-    return `Config file at ${stringField(configJson, "path")} is not valid JSON(C)` + (message ? `: ${message}` : "")
-  }
-
-  // ConfigDirectoryTypoError: { dir: string, path: string, suggestion: string }
-  const configDirectoryTypo = configData(input, "ConfigDirectoryTypoError")
-  if (configDirectoryTypo) {
-    return `Directory "${stringField(configDirectoryTypo, "dir")}" in ${stringField(configDirectoryTypo, "path")} is not valid. Rename the directory to "${stringField(configDirectoryTypo, "suggestion")}" or remove it. This is a common typo.`
-  }
-
-  // ConfigFrontmatterError: { message: string }
-  const configFrontmatter = configData(input, "ConfigFrontmatterError")
-  if (configFrontmatter) {
-    return stringField(configFrontmatter, "message") ?? ""
-  }
-
-  // ConfigRemoteAuthError: { url: string, remote: string }
-  const remoteAuth = configData(input, "ConfigRemoteAuthError")
-  if (remoteAuth) {
-    const url = stringField(remoteAuth, "url")
-    const remote = stringField(remoteAuth, "remote")
-    return [
-      `Failed to load remote config${remote ? ` from ${remote}` : ""}: the server returned a login page instead of JSON.`,
-      `Authentication is missing or has expired (the endpoint is likely behind an SSO or identity-aware proxy).`,
-      ...(url ? [`Run \`anymous auth login ${url}\` to re-authenticate.`] : []),
-    ].join("\n")
-  }
-
-  // ConfigInvalidError: { path?: string, message?: string, issues?: Array<{ message: string, path: string[] }> }
-  const configInvalid = configData(input, "ConfigInvalidError")
-  if (configInvalid) {
-    const path = stringField(configInvalid, "path")
-    const message = stringField(configInvalid, "message")
-    const issues = configIssues(configInvalid)
-    return [
-      `Configuration is invalid${path && path !== "config" ? ` at ${path}` : ""}` + (message ? `: ${message}` : ""),
-      ...issues.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")),
-    ].join("\n")
-  }
-
-  // UICancelledError: user cancelled an interactive CLI prompt
-  if (isTaggedError(input, "UICancelledError") || NamedError.hasName(input, "UICancelledError")) {
-    return ""
-  }
-  return undefined
-}
-
-export function FormatUnknownError(input: unknown): string {
-  return errorFormat(input)
-}

package/src/cli/heap.ts

@@ -1,45 +0,0 @@
-import path from "path"
-import { writeHeapSnapshot } from "node:v8"
-import { Flag } from "@anymous-ai/core/flag/flag"
-import { Global } from "@anymous-ai/core/global"
-const MINUTE = 60_000
-const LIMIT = 2 * 1024 * 1024 * 1024
-
-let timer: Timer | undefined
-let lock = false
-let armed = true
-
-export function start() {
-  if (!Flag.ANYMOUS_AUTO_HEAP_SNAPSHOT) return
-  if (timer) return
-
-  const run = async () => {
-    if (lock) return
-
-    const stat = process.memoryUsage()
-    if (stat.rss <= LIMIT) {
-      armed = true
-      return
-    }
-    if (!armed) return
-
-    lock = true
-    armed = false
-    const file = path.join(
-      Global.Path.log,
-      `heap-${process.pid}-${new Date().toISOString().replace(/[:.]/g, "")}.heapsnapshot`,
-    )
-    await Promise.resolve()
-      .then(() => writeHeapSnapshot(file))
-      .catch(() => {})
-
-    lock = false
-  }
-
-  timer = setInterval(() => {
-    void run()
-  }, MINUTE)
-  timer.unref?.()
-}
-
-export * as Heap from "./heap"

package/src/cli/logo.ts

@@ -1 +0,0 @@
-export * from "@anymous-ai/tui/logo"

package/src/cli/network.ts

@@ -1,80 +0,0 @@
-import type { Argv, InferredOptionTypes } from "yargs"
-import { ConfigV1 } from "@anymous-ai/core/v1/config/config"
-import type { Config } from "@/config/config"
-import { Effect } from "effect"
-
-const options = {
-  port: {
-    type: "number" as const,
-    describe: "port to listen on",
-    default: 0,
-  },
-  hostname: {
-    type: "string" as const,
-    describe: "hostname to listen on",
-    default: "127.0.0.1",
-  },
-  mdns: {
-    type: "boolean" as const,
-    describe: "enable mDNS service discovery (defaults hostname to 0.0.0.0)",
-    default: false,
-  },
-  "mdns-domain": {
-    type: "string" as const,
-    describe: "custom domain name for mDNS service (default: anymous.local)",
-    default: "anymous.local",
-  },
-  cors: {
-    type: "string" as const,
-    array: true,
-    describe: "additional domains to allow for CORS",
-    default: [] as string[],
-  },
-}
-
-export type NetworkOptions = InferredOptionTypes<typeof options>
-
-export function withNetworkOptions<T>(yargs: Argv<T>) {
-  return yargs.options(options)
-}
-
-export function hasArg(name: string) {
-  return networkArgs().some((arg) => arg === name || arg.startsWith(name + "="))
-}
-
-function hasBooleanArg(name: string) {
-  return networkArgs().some(
-    (arg) => arg === name || arg === name + "=true" || arg === name + "=false" || arg === "--no-" + name.slice(2),
-  )
-}
-
-function networkArgs() {
-  const separator = process.argv.indexOf("--")
-  return process.argv.slice(2, separator === -1 ? undefined : separator)
-}
-
-export const resolveNetworkOptions = Effect.fn("Cli.resolveNetworkOptions")(function* (args: NetworkOptions) {
-  const { Config } = yield* Effect.promise(() => import("@/config/config"))
-  const config = yield* Config.Service.use((cfg) => cfg.getGlobal())
-  return resolveNetworkOptionsNoConfig(args, config)
-})
-
-export function resolveNetworkOptionsNoConfig(args: NetworkOptions, config?: ConfigV1.Info) {
-  const portExplicitlySet = hasArg("--port")
-  const hostnameExplicitlySet = hasArg("--hostname")
-  const mdnsExplicitlySet = hasBooleanArg("--mdns")
-  const mdnsDomainExplicitlySet = hasArg("--mdns-domain")
-  const mdns = mdnsExplicitlySet ? args.mdns : (config?.server?.mdns ?? args.mdns)
-  const mdnsDomain = mdnsDomainExplicitlySet ? args["mdns-domain"] : (config?.server?.mdnsDomain ?? args["mdns-domain"])
-  const port = portExplicitlySet ? args.port : (config?.server?.port ?? args.port)
-  const hostname = hostnameExplicitlySet
-    ? args.hostname
-    : mdns && !config?.server?.hostname
-      ? "0.0.0.0"
-      : (config?.server?.hostname ?? args.hostname)
-  const configCors = config?.server?.cors ?? []
-  const argsCors = Array.isArray(args.cors) ? args.cors : args.cors ? [args.cors] : []
-  const cors = [...configCors, ...argsCors]
-
-  return { hostname, port, mdns, mdnsDomain, cors }
-}

package/src/cli/tui/layer.ts

@@ -1,8 +0,0 @@
-import { run as runTui, type TuiInput } from "@anymous-ai/tui"
-import { Global } from "@anymous-ai/core/global"
-import { AppNodeBuilder } from "@anymous-ai/core/effect/app-node-builder"
-import { Effect } from "effect"
-
-export function run(input: TuiInput) {
-  return runTui(input).pipe(Effect.provide(AppNodeBuilder.build(Global.node)))
-}

package/src/cli/tui/validate-session.ts

@@ -1,29 +0,0 @@
-import { createanymousClient } from "@anymous-ai/sdk/v2"
-import { SessionID } from "@/session/schema"
-import { Schema } from "effect"
-
-const decodeSessionID = Schema.decodeUnknownSync(SessionID)
-
-export async function validateSession(input: {
-  url: string
-  sessionID?: string
-  directory?: string
-  fetch?: typeof fetch
-  headers?: RequestInit["headers"]
-}) {
-  if (!input.sessionID) return
-
-  let sessionID: SessionID
-  try {
-    sessionID = decodeSessionID(input.sessionID)
-  } catch (error) {
-    throw new Error(`Invalid session ID: ${error instanceof Error ? error.message : "unknown error"}`, { cause: error })
-  }
-
-  await createanymousClient({
-    baseUrl: input.url,
-    directory: input.directory,
-    fetch: input.fetch,
-    headers: input.headers,
-  }).session.get({ sessionID }, { throwOnError: true })
-}