@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/ide/index.ts

@@ -1,73 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import z from "zod"
-import { NamedError } from "@sleepy-ai/shared/util/error"
-import { Log } from "../util"
-import { Process } from "@/util"
-
-const SUPPORTED_IDES = [
-  { name: "Windsurf" as const, cmd: "windsurf" },
-  { name: "Visual Studio Code - Insiders" as const, cmd: "code-insiders" },
-  { name: "Visual Studio Code" as const, cmd: "code" },
-  { name: "Cursor" as const, cmd: "cursor" },
-  { name: "VSCodium" as const, cmd: "codium" },
-]
-
-const log = Log.create({ service: "ide" })
-
-export const Event = {
-  Installed: BusEvent.define(
-    "ide.installed",
-    z.object({
-      ide: z.string(),
-    }),
-  ),
-}
-
-export const AlreadyInstalledError = NamedError.create("AlreadyInstalledError", z.object({}))
-
-export const InstallFailedError = NamedError.create(
-  "InstallFailedError",
-  z.object({
-    stderr: z.string(),
-  }),
-)
-
-export function ide() {
-  if (process.env["TERM_PROGRAM"] === "vscode") {
-    const v = process.env["GIT_ASKPASS"]
-    for (const ide of SUPPORTED_IDES) {
-      if (v?.includes(ide.name)) return ide.name
-    }
-  }
-  return "unknown"
-}
-
-export function alreadyInstalled() {
-  return process.env["OPENCODE_CALLER"] === "vscode" || process.env["OPENCODE_CALLER"] === "vscode-insiders"
-}
-
-export async function install(ide: (typeof SUPPORTED_IDES)[number]["name"]) {
-  const cmd = SUPPORTED_IDES.find((i) => i.name === ide)?.cmd
-  if (!cmd) throw new Error(`Unknown IDE: ${ide}`)
-
-  const p = await Process.run([cmd, "--install-extension", "sst-dev.opencode"], {
-    nothrow: true,
-  })
-  const stdout = p.stdout.toString()
-  const stderr = p.stderr.toString()
-
-  log.info("installed", {
-    ide,
-    stdout,
-    stderr,
-  })
-
-  if (p.code !== 0) {
-    throw new InstallFailedError({ stderr })
-  }
-  if (stdout.includes("already installed")) {
-    throw new AlreadyInstalledError({})
-  }
-}
-
-export * as Ide from "."

package/src/inbox/inbox-ref.ts

@@ -1,38 +0,0 @@
-// Late-bound reference to SessionPrompt.loop. Mirrors actor/spawn-ref.ts.
-//
-// Inbox.send needs to "wake" a receiver — i.e. make sure SessionPrompt.loop
-// runs once for (receiverSessionID, receiverActorID). Wiring SessionPrompt
-// as a normal Layer dependency would form a cycle: SessionPrompt.runLoop
-// already calls inbox.drain at the head of every iteration, so Inbox cannot
-// also depend on SessionPrompt.
-//
-// SessionPrompt.layer populates `current` at initialisation; Inbox.send
-// reads it at call time. A missing `current` is treated as a runtime guard
-// (test fixtures that don't bring up SessionPrompt; renderer-only paths) —
-// send still INSERTs the row, but no wake fiber is scheduled.
-import type { Effect } from "effect"
-import type { SessionID } from "@/session/schema"
-import type { MessageV2 } from "@/session/message-v2"
-import type { Interface as InboxInterface } from "./inbox"
-
-export interface SessionPromptLoopRef {
-  loop: (input: { sessionID: SessionID; agentID: string }) => Effect.Effect<MessageV2.WithParts>
-}
-
-export const sessionPromptRef: { current: SessionPromptLoopRef | undefined } = {
-  current: undefined,
-}
-
-// Late-bound reference to Inbox.Service.
-//
-// tool/actor.ts needs to call inbox.send for the "send" action, but wiring
-// Inbox.Service as a normal Layer dependency would require all callers of
-// ActorTool to also provide Inbox.Service (including test fixtures that
-// don't use the send action). Using this ref keeps the dependency optional:
-// send fails gracefully if the inbox service is not available.
-//
-// Inbox.layer populates `current` at initialisation. A missing `current`
-// means the inbox service hasn't been wired (e.g. minimal test fixtures).
-export const inboxServiceRef: { current: InboxInterface | undefined } = {
-  current: undefined,
-}

package/src/inbox/inbox.sql.ts

@@ -1,26 +0,0 @@
-import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core"
-import { SessionTable } from "../session/session.sql"
-import type { SessionID } from "../session/schema"
-
-export const InboxTable = sqliteTable(
-  "inbox",
-  {
-    id: text().primaryKey(),
-    receiver_session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    receiver_actor_id: text().notNull(),
-    sender_session_id: text().$type<SessionID>(),
-    sender_actor_id: text(),
-    type: text().notNull().default("text"),
-    content: text({ mode: "json" }).$type<unknown>().notNull(),
-    created_at: integer().notNull(),
-  },
-  (t) => [
-    index("inbox_receiver_idx").on(t.receiver_session_id, t.receiver_actor_id, t.id),
-    index("inbox_created_idx").on(t.created_at),
-  ],
-)
-
-export type InboxRow = typeof InboxTable.$inferSelect

package/src/inbox/inbox.ts

@@ -1,223 +0,0 @@
-import { Context, Effect, Layer, Scope, Schema } from "effect"
-import { ulid } from "ulid"
-import { Database, eq, and, lte, inArray } from "@/storage"
-import { Bus } from "@/bus"
-import { ActorRegistry } from "@/actor/registry"
-import { Session } from "@/session"
-import { MessageID, PartID } from "@/session/schema"
-import { InboxArrived } from "@/actor/events"
-import type { SessionID } from "@/session/schema"
-import { Log } from "@/util"
-import { InboxTable } from "./inbox.sql"
-import { renderInboxRow } from "./render"
-import { sessionPromptRef, inboxServiceRef } from "./inbox-ref"
-
-const log = Log.create({ service: "inbox" })
-
-const GC_TTL_MS = 7 * 24 * 60 * 60 * 1000
-export const MAX_DRAIN_PER_TURN = 100
-
-/** Delete inbox rows whose created_at is at or before cutoffMs. Unit-testable without layer reset. */
-export function gcInboxRows(cutoffMs: number) {
-  return Effect.sync(() =>
-    Database.use((db) => db.delete(InboxTable).where(lte(InboxTable.created_at, cutoffMs)).run()),
-  )
-}
-
-export class InboxReceiverNotFound extends Schema.TaggedErrorClass<InboxReceiverNotFound>()(
-  "InboxReceiverNotFound",
-  {
-    receiverSessionID: Schema.String,
-    receiverActorID: Schema.String,
-  },
-) {}
-
-export interface SendInput {
-  receiverSessionID: SessionID
-  receiverActorID: string
-  senderSessionID?: SessionID
-  senderActorID?: string
-  content: string
-  type?: string
-}
-
-export interface SendResult {
-  inboxID: string
-}
-
-export interface Interface {
-  readonly send: (input: SendInput) => Effect.Effect<SendResult, InboxReceiverNotFound>
-  readonly drain: (sessionID: SessionID, actorID: string) => Effect.Effect<number>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Inbox") {}
-
-export const layer: Layer.Layer<
-  Service,
-  never,
-  Bus.Service | ActorRegistry.Service | Session.Service
-> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const reg = yield* ActorRegistry.Service
-    const sessions = yield* Session.Service
-    const scope = yield* Scope.Scope
-
-    // 7-day GC at init. Idempotent: deletes any rows older than now-7d.
-    yield* gcInboxRows(Date.now() - GC_TTL_MS)
-    log.info("inbox gc-on-init complete")
-
-    const send = Effect.fn("Inbox.send")(function* (input: SendInput) {
-      // ESRCH check (B3). receiver row must exist.
-      const receiver = yield* reg.get(input.receiverSessionID, input.receiverActorID)
-      if (!receiver) {
-        return yield* Effect.fail(
-          new InboxReceiverNotFound({
-            receiverSessionID: input.receiverSessionID,
-            receiverActorID: input.receiverActorID,
-          }),
-        )
-      }
-
-      const row = {
-        id: ulid(),
-        receiver_session_id: input.receiverSessionID,
-        receiver_actor_id: input.receiverActorID,
-        sender_session_id: input.senderSessionID ?? null,
-        sender_actor_id: input.senderActorID ?? null,
-        type: input.type ?? "text",
-        content: { text: input.content },
-        created_at: Date.now(),
-      }
-      yield* Effect.sync(() => Database.use((db) => db.insert(InboxTable).values(row).run()))
-      yield* bus.publish(InboxArrived, {
-        receiverSessionID: input.receiverSessionID,
-        receiverActorID: input.receiverActorID,
-        ...(input.senderSessionID !== undefined ? { senderSessionID: input.senderSessionID } : {}),
-        ...(input.senderActorID !== undefined ? { senderActorID: input.senderActorID } : {}),
-        inboxID: row.id,
-        type: row.type,
-      })
-
-      // Fork-and-forget wake (B2). Sender returns after fork is scheduled;
-      // wake fiber lives in the service scope, so sender lifecycle does
-      // not affect delivery.
-      const promptRef = sessionPromptRef.current
-      if (promptRef) {
-        yield* promptRef
-          .loop({ sessionID: input.receiverSessionID, agentID: input.receiverActorID })
-          .pipe(Effect.ignore, Effect.forkIn(scope))
-      } else {
-        // Test fixtures / renderer-only paths can run without SessionPrompt.
-        // Row is durable; will be drained on next runLoop iteration.
-        log.warn("inbox.send: sessionPromptRef.current undefined — wake skipped", {
-          receiverActorID: input.receiverActorID,
-        })
-      }
-
-      return { inboxID: row.id }
-    })
-
-    const drain = Effect.fn("Inbox.drain")(function* (
-      sessionID: SessionID,
-      actorID: string,
-    ) {
-      // Cheap indexed SELECT first — if inbox is empty, bail immediately.
-      // Common case: every iteration discovers nothing to drain.
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(InboxTable)
-            .where(
-              and(
-                eq(InboxTable.receiver_session_id, sessionID),
-                eq(InboxTable.receiver_actor_id, actorID),
-              ),
-            )
-            .orderBy(InboxTable.id)
-            .limit(MAX_DRAIN_PER_TURN)
-            .all(),
-        ),
-      )
-      if (rows.length === 0) return 0
-
-      // Find the most recent real (non-system) assistant in this slice so the
-      // synthetic user message inherits its agent + model. Pulled into Inbox
-      // module so plan 3 can delete actor/completion.ts wholesale.
-      const sliceMessages = yield* sessions.messages({ sessionID, agentID: actorID })
-      const lastReal = sliceMessages.findLast(
-        (m) =>
-          (m.info.role === "user" || m.info.role === "assistant") &&
-          "model" in m.info &&
-          m.info.model !== undefined &&
-          m.info.model.providerID !== "system" &&
-          m.info.agent !== "system",
-      )
-      if (
-        !lastReal ||
-        !("model" in lastReal.info) ||
-        !lastReal.info.model ||
-        !("agent" in lastReal.info)
-      ) {
-        // Slice has no real assistant yet — defer the drain. Rows stay in the
-        // inbox; next iteration after a real turn will pick them up.
-        return 0
-      }
-
-      // Non-transactional crash window: updateMessage + updatePart commit
-      // before the inbox DELETE. A crash between them re-renders the same
-      // rows on next drain — LLM sees duplicated notifications. Tolerable;
-      // a transactional fix would require threading tx through
-      // sessions.updateMessage/updatePart, which crosses three abstraction
-      // layers.
-      const msgID = MessageID.ascending()
-      const now = Date.now()
-      yield* sessions.updateMessage({
-        id: msgID,
-        role: "user" as const,
-        sessionID,
-        agentID: actorID,
-        time: { created: now },
-        agent: lastReal.info.agent,
-        model: lastReal.info.model,
-      })
-      for (const row of rows) {
-        yield* sessions.updatePart({
-          id: PartID.ascending(),
-          messageID: msgID,
-          sessionID,
-          type: "text" as const,
-          synthetic: true,
-          text: renderInboxRow(row),
-        })
-      }
-      yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .delete(InboxTable)
-            .where(inArray(InboxTable.id, rows.map((r) => r.id)))
-            .run(),
-        ),
-      )
-
-      return rows.length
-    })
-
-    const impl = Service.of({ send, drain })
-    inboxServiceRef.current = impl
-    yield* Effect.addFinalizer(() =>
-      Effect.sync(() => {
-        if (inboxServiceRef.current === impl) inboxServiceRef.current = undefined
-      }),
-    )
-    return impl
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(Bus.defaultLayer),
-  Layer.provide(ActorRegistry.defaultLayer),
-  Layer.provide(Session.defaultLayer),
-)

package/src/inbox/index.ts

@@ -1,3 +0,0 @@
-export * as Inbox from "./inbox"
-export { InboxTable, type InboxRow } from "./inbox.sql"
-export { sessionPromptRef } from "./inbox-ref"

package/src/inbox/render.ts

@@ -1,40 +0,0 @@
-import type { InboxRow } from "./inbox.sql"
-
-export function renderInboxRow(row: InboxRow): string {
-  if (row.type === "actor_notification") {
-    // Pre-rendered notification text — sender produced the full
-    // <actor-notification>...</actor-notification> wrapper.
-    const content = row.content as { text?: string }
-    return content.text ?? "(no notification body)"
-  }
-  // Default: type === "text" or unknown — wrap as <inbox> element so
-  // the LLM can route by sender; the wrapper format mirrors the
-  // <actor-notification> convention from the legacy completion.ts.
-  const content = row.content as { text?: string }
-  const sender = row.sender_session_id
-    ? `${row.sender_session_id}:${row.sender_actor_id ?? "?"}`
-    : "system"
-  const sentAt = new Date(row.created_at).toISOString()
-  return `<inbox from="${sender}" sent_at="${sentAt}">\n${content.text ?? "(empty)"}\n</inbox>`
-}
-
-export function renderActorNotification(event: {
-  actorID: string
-  description: string
-  status: "completed" | "failed" | "cancelled"
-  result?: string
-  error?: string
-  reportedStatus?: string
-  reportedSummary?: string
-}): string {
-  const header = `Background actor "${event.description}" (actor_id: ${event.actorID})`
-  if (event.status === "completed") {
-    const statusLine = `Status: ${event.reportedStatus ?? "unknown"}`
-    const summaryLine = event.reportedSummary ? `\nSummary: ${event.reportedSummary}` : ""
-    return `<actor-notification>\n${header} completed.\n${statusLine}${summaryLine}\nResult: ${event.result ?? "(no output)"}\n</actor-notification>`
-  }
-  if (event.status === "failed") {
-    return `<actor-notification>\n${header} failed.\nError: ${event.error ?? "unknown"}\n</actor-notification>`
-  }
-  return `<actor-notification>\n${header} was cancelled.\n</actor-notification>`
-}

package/src/index.ts

@@ -1,268 +0,0 @@
-import yargs from "yargs"
-import { hideBin } from "yargs/helpers"
-import { RunCommand } from "./cli/cmd/run"
-import { GenerateCommand } from "./cli/cmd/generate"
-import { Log } from "./util"
-import { ConsoleCommand } from "./cli/cmd/account"
-import { ProvidersCommand } from "./cli/cmd/providers"
-import { AgentCommand } from "./cli/cmd/agent"
-import { UpgradeCommand } from "./cli/cmd/upgrade"
-import { UninstallCommand } from "./cli/cmd/uninstall"
-import { ModelsCommand } from "./cli/cmd/models"
-import { UI } from "./cli/ui"
-import { Installation } from "./installation"
-import { InstallationVersion } from "./installation/version"
-import { NamedError } from "@sleepy-ai/shared/util/error"
-import { FormatError } from "./cli/error"
-import { ServeCommand } from "./cli/cmd/serve"
-import { Filesystem } from "./util"
-import { DebugCommand } from "./cli/cmd/debug"
-import { StatsCommand } from "./cli/cmd/stats"
-import { McpCommand } from "./cli/cmd/mcp"
-import { GithubCommand } from "./cli/cmd/github"
-import { ExportCommand } from "./cli/cmd/export"
-import { ImportCommand } from "./cli/cmd/import"
-import { AttachCommand } from "./cli/cmd/tui/attach"
-import { TuiThreadCommand } from "./cli/cmd/tui/thread"
-import { AcpCommand } from "./cli/cmd/acp"
-import { EOL } from "os"
-// Web command temporarily disabled
-// import { WebCommand } from "./cli/cmd/web"
-import { PrCommand } from "./cli/cmd/pr"
-import { SessionCommand } from "./cli/cmd/session"
-import { DbCommand } from "./cli/cmd/db"
-import path from "path"
-import { Global } from "./global"
-import { JsonMigration } from "./storage"
-import { Database } from "./storage"
-import { ClaudeImport } from "./session/claude-import"
-import { errorMessage } from "./util/error"
-import { PluginCommand } from "./cli/cmd/plug"
-import { Heap } from "./cli/heap"
-import { drizzle } from "drizzle-orm/bun-sqlite"
-import { ensureProcessMetadata } from "./util/sleepy-process"
-import { LoginCommand } from "./cli/cmd/login"
-import { InitCommand } from "./cli/cmd/init"
-import { DoctorCommand } from "./cli/cmd/doctor"
-
-const processMetadata = ensureProcessMetadata("main")
-
-process.on("unhandledRejection", (e) => {
-  Log.Default.error("rejection", {
-    e: errorMessage(e),
-  })
-})
-
-process.on("uncaughtException", (e) => {
-  Log.Default.error("exception", {
-    e: errorMessage(e),
-  })
-})
-
-const args = hideBin(process.argv)
-
-function show(out: string) {
-  const text = out.trimStart()
-    if (!text.startsWith("sleepy ")) {
-    process.stderr.write(UI.logo() + EOL + EOL)
-    process.stderr.write(text)
-    return
-  }
-  process.stderr.write(out)
-}
-
-const cli = yargs(args)
-  .parserConfiguration({ "populate--": true })
-  .scriptName("sleepy")
-  .wrap(100)
-  .help("help", "show help")
-  .alias("help", "h")
-  .version("version", "show version number", InstallationVersion)
-  .alias("version", "v")
-  .option("print-logs", {
-    describe: "print logs to stderr",
-    type: "boolean",
-  })
-  .option("log-level", {
-    describe: "log level",
-    type: "string",
-    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-  })
-  .option("pure", {
-    describe: "run without external plugins",
-    type: "boolean",
-  })
-  .middleware(async (opts) => {
-    if (opts.pure) {
-      process.env.SLEEPYCODE_PURE = "1"
-    }
-
-    await Log.init({
-      print: process.argv.includes("--print-logs"),
-      dev: Installation.isLocal(),
-      level: (() => {
-        if (opts.logLevel) return opts.logLevel as Log.Level
-        if (Installation.isLocal()) return "DEBUG"
-        return "INFO"
-      })(),
-    })
-
-    Heap.start()
-
-    process.env.AGENT = "1"
-    process.env.SLEEPYCODE = "1"
-    process.env.SLEEPYCODE_PID = String(process.pid)
-
-    Log.Default.info("sleepycode", {
-      version: InstallationVersion,
-      args: process.argv.slice(2),
-      process_role: processMetadata.processRole,
-      run_id: processMetadata.runID,
-    })
-
-    const marker = path.join(Global.Path.data, "sleepy.db")
-    if (!(await Filesystem.exists(marker))) {
-      const tty = process.stderr.isTTY
-      process.stderr.write("Performing one time database migration, may take a few minutes..." + EOL)
-      const width = 36
-      const orange = "\x1b[38;5;214m"
-      const muted = "\x1b[0;2m"
-      const reset = "\x1b[0m"
-      let last = -1
-      if (tty) process.stderr.write("\x1b[?25l")
-      try {
-        await JsonMigration.run(drizzle({ client: Database.Client().$client }), {
-          progress: (event) => {
-            const percent = Math.floor((event.current / event.total) * 100)
-            if (percent === last && event.current !== event.total) return
-            last = percent
-            if (tty) {
-              const fill = Math.round((percent / 100) * width)
-              const bar = `${"■".repeat(fill)}${"･".repeat(width - fill)}`
-              process.stderr.write(
-                `\r${orange}${bar} ${percent.toString().padStart(3)}%${reset} ${muted}${event.label.padEnd(12)} ${event.current}/${event.total}${reset}`,
-              )
-              if (event.current === event.total) process.stderr.write("\n")
-            } else {
-              process.stderr.write(`sqlite-migration:${percent}${EOL}`)
-            }
-          },
-        })
-      } finally {
-        if (tty) process.stderr.write("\x1b[?25h")
-        else {
-          process.stderr.write(`sqlite-migration:done${EOL}`)
-        }
-      }
-      process.stderr.write("Database migration complete." + EOL)
-    }
-
-    // Idempotently import Claude Code sessions into SQLite. Runs once per process
-    // tree (the env guard is inherited by spawned children) and is best-effort:
-    // a failure here must never block command startup.
-    if (!process.env.SLEEPYCODE_DISABLE_CLAUDE_IMPORT && !process.env.SLEEPYCODE_CLAUDE_IMPORTED) {
-      process.env.SLEEPYCODE_CLAUDE_IMPORTED = "1"
-      try {
-        await ClaudeImport.run()
-      } catch (e) {
-        Log.Default.warn("claude-import failed", { e: errorMessage(e) })
-      }
-    }
-  })
-  .usage("")
-  .completion("completion", "generate shell completion script")
-  .command(AcpCommand)
-  .command(McpCommand)
-  .command(TuiThreadCommand)
-  .command(AttachCommand)
-  .command(RunCommand)
-  .command(GenerateCommand)
-  .command(DebugCommand)
-  .command(ConsoleCommand)
-  .command(ProvidersCommand)
-  .command(AgentCommand)
-  .command(UpgradeCommand)
-  .command(UninstallCommand)
-  .command(ServeCommand)
-  // Web command temporarily disabled
-  // .command(WebCommand)
-  .command(ModelsCommand)
-  .command(StatsCommand)
-  .command(ExportCommand)
-  .command(ImportCommand)
-  .command(GithubCommand)
-  .command(PrCommand)
-  .command(SessionCommand)
-  .command(PluginCommand)
-  .command(DbCommand)
-  .command(LoginCommand)
-  .command(InitCommand)
-  .command(DoctorCommand)
-  .fail((msg, err) => {
-    if (
-      msg?.startsWith("Unknown argument") ||
-      msg?.startsWith("Not enough non-option arguments") ||
-      msg?.startsWith("Invalid values:")
-    ) {
-      if (err) throw err
-      cli.showHelp(show)
-    }
-    if (err) throw err
-    process.exit(1)
-  })
-  .strict()
-
-try {
-  if (args.includes("-h") || args.includes("--help")) {
-    await cli.parse(args, (err: Error | undefined, _argv: unknown, out: string) => {
-      if (err) throw err
-      if (!out) return
-      show(out)
-    })
-  } else {
-    await cli.parse()
-  }
-} catch (e) {
-  let data: Record<string, any> = {}
-  if (e instanceof NamedError) {
-    const obj = e.toObject()
-    Object.assign(data, {
-      ...obj.data,
-    })
-  }
-
-  if (e instanceof Error) {
-    Object.assign(data, {
-      name: e.name,
-      message: e.message,
-      cause: e.cause?.toString(),
-      stack: e.stack,
-    })
-  }
-
-  if (e instanceof ResolveMessage) {
-    Object.assign(data, {
-      name: e.name,
-      message: e.message,
-      code: e.code,
-      specifier: e.specifier,
-      referrer: e.referrer,
-      position: e.position,
-      importKind: e.importKind,
-    })
-  }
-  Log.Default.error("fatal", data)
-  const formatted = FormatError(e)
-  if (formatted) UI.error(formatted)
-  if (formatted === undefined) {
-    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
-    process.stderr.write(errorMessage(e) + EOL)
-  }
-  process.exitCode = 1
-} finally {
-  // Some subprocesses don't react properly to SIGTERM and similar signals.
-  // Most notably, some docker-container-based MCP servers don't handle such signals unless
-  // run using `docker run --init`.
-  // Explicitly exit to avoid any hanging subprocesses.
-  process.exit()
-}