@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/ide/index.ts

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,223 @@
+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

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

package/src/inbox/render.ts

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,268 @@
+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()
+}