onlycode 1.18.0 → 1.20.0

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 "@opencode-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 opencode server and open web interface",
-  // Server loads instances per-request via x-opencode-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.OPENCODE_SERVER_PASSWORD) {
-      UI.println(UI.Style.TEXT_WARNING_BOLD + "!  OPENCODE_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 "@opencode-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, opencode 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: \`opencode models\` to list available models`,
-      `Or check your config (opencode.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 \`opencode 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 "@opencode-ai/core/flag/flag"
-import { Global } from "@opencode-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.OPENCODE_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-pixel.ts

@@ -1,35 +0,0 @@
-// ONLYCODE pixel-style Logo
-// Each letter 8 chars wide, 7 rows tall, 1 space between letters
-
-export const pixelLogo = {
-  only: [
-    "████████ ██    ██ ██       ██    ██",
-    "██    ██ ███   ██ ██       ██    ██",
-    "██    ██ ████  ██ ██        ██  ██ ",
-    "██    ██ ████████ ██         ████  ",
-    "██    ██ ██  ████ ██          ██   ",
-    "██    ██ ██   ███ ██          ██   ",
-    "████████ ██    ██ ████████    ██   "
-  ],
-  code: [
-    "████████ ████████ ██████   ████████",
-    "██       ██    ██ ██    ██ ██      ",
-    "██       ██    ██ ██    ██ ██      ",
-    "██       ██    ██ ██    ██ ████████",
-    "██       ██    ██ ██    ██ ██      ",
-    "██       ██    ██ ██    ██ ██      ",
-    "████████ ████████ ██████   ████████"
-  ],
-}
-
-// Color config
-export const pixelColors = {
-  only: {
-    fg: "#22c55e",
-    style: "bold #22c55e",
-  },
-  code: {
-    fg: "#4ade80",
-    style: "bold #4ade80",
-  },
-}

package/src/cli/logo.ts

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

package/src/cli/network.ts

@@ -1,64 +0,0 @@
-import type { Argv, InferredOptionTypes } from "yargs"
-import { ConfigV1 } from "@opencode-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: opencode.local)",
-    default: "opencode.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 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 = process.argv.includes("--port")
-  const hostnameExplicitlySet = process.argv.includes("--hostname")
-  const mdnsExplicitlySet = process.argv.includes("--mdns")
-  const mdnsDomainExplicitlySet = process.argv.includes("--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,7 +0,0 @@
-import { run as runTui, type TuiInput } from "@opencode-ai/tui"
-import { Global } from "@opencode-ai/core/global"
-import { Effect } from "effect"
-
-export function run(input: TuiInput) {
-  return runTui(input).pipe(Effect.provide(Global.defaultLayer))
-}

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

@@ -1,29 +0,0 @@
-import { createOpencodeClient } from "@opencode-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 createOpencodeClient({
-    baseUrl: input.url,
-    directory: input.directory,
-    fetch: input.fetch,
-    headers: input.headers,
-  }).session.get({ sessionID }, { throwOnError: true })
-}

package/src/cli/tui/worker.ts

@@ -1,71 +0,0 @@
-import { Server } from "@/server/server"
-import { InstanceRuntime } from "@/project/instance-runtime"
-import { Rpc } from "@/util/rpc"
-import { upgrade } from "@/cli/upgrade"
-import { Config } from "@/config/config"
-import { GlobalBus } from "@/bus/global"
-import { ServerAuth } from "@/server/auth"
-import { writeHeapSnapshot } from "node:v8"
-import { Heap } from "@/cli/heap"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Effect } from "effect"
-import { disposeAllInstancesAndEmitGlobalDisposed } from "@/server/global-lifecycle"
-
-Heap.start()
-
-// Subscribe to global events and forward them via RPC
-GlobalBus.on("event", (event) => {
-  Rpc.emit("global.event", event)
-})
-
-let server: Awaited<ReturnType<typeof Server.listen>> | undefined
-
-export const rpc = {
-  async fetch(input: { url: string; method: string; headers: Record<string, string>; body?: string }) {
-    const headers = { ...input.headers }
-    const auth = ServerAuth.header()
-    if (auth && !headers["authorization"] && !headers["Authorization"]) {
-      headers["Authorization"] = auth
-    }
-    const request = new Request(input.url, {
-      method: input.method,
-      headers,
-      body: input.body,
-    })
-    const response = await Server.Default().app.fetch(request)
-    const body = await response.text()
-    return {
-      status: response.status,
-      headers: Object.fromEntries(response.headers.entries()),
-      body,
-    }
-  },
-  snapshot() {
-    const result = writeHeapSnapshot("server.heapsnapshot")
-    return result
-  },
-  async server(input: { port: number; hostname: string; mdns?: boolean; cors?: string[] }) {
-    if (server) await server.stop(true)
-    server = await Server.listen(input)
-    return { url: server.url.toString() }
-  },
-  async checkUpgrade(input: { directory: string }) {
-    await InstanceRuntime.load({ directory: input.directory })
-    await upgrade().catch(() => {})
-  },
-  async reload() {
-    await AppRuntime.runPromise(
-      Effect.gen(function* () {
-        const cfg = yield* Config.Service
-        yield* cfg.invalidate()
-        yield* disposeAllInstancesAndEmitGlobalDisposed({ swallowErrors: true })
-      }),
-    )
-  },
-  async shutdown() {
-    await InstanceRuntime.disposeAllInstances()
-    if (server) await server.stop(true)
-  },
-}
-
-Rpc.listen(rpc)