@agentprojectcontext/apx 1.15.5 → 1.16.0

package/src/tui/routes/session/subagent-footer.tsx

@@ -0,0 +1,133 @@
+import { createMemo, createSignal, Show } from "solid-js"
+import { useRouteData } from "@tui/context/route"
+import { useSync } from "@tui/context/sync"
+import { useTheme } from "@tui/context/theme"
+import { SplitBorder } from "@tui/component/border"
+import type { AssistantMessage } from "@opencode-ai/sdk/v2"
+import { Locale } from "@/util/locale"
+import { useTerminalDimensions } from "@opentui/solid"
+import { useCommandPalette } from "../../context/command-palette"
+import { useCommandShortcut } from "../../keymap"
+
+export function SubagentFooter() {
+  const route = useRouteData("session")
+  const sync = useSync()
+  const messages = createMemo(() => sync.data.message[route.sessionID] ?? [])
+  const session = createMemo(() => sync.session.get(route.sessionID))
+
+  const subagentInfo = createMemo(() => {
+    const s = session()
+    if (!s) return { label: "Subagent", index: 0, total: 0 }
+    const agentMatch = s.title.match(/@(\w+) subagent/)
+    const label = agentMatch ? Locale.titlecase(agentMatch[1]) : "Subagent"
+
+    if (!s.parentID) return { label, index: 0, total: 0 }
+
+    const siblings = sync.data.session
+      .filter((x) => x.parentID === s.parentID)
+      .toSorted((a, b) => a.time.created - b.time.created)
+    const index = siblings.findIndex((x) => x.id === s.id)
+
+    return { label, index: index + 1, total: siblings.length }
+  })
+
+  const usage = createMemo(() => {
+    const msg = messages()
+    const last = msg.findLast((item): item is AssistantMessage => item.role === "assistant" && item.tokens.output > 0)
+    if (!last) return
+
+    const tokens =
+      last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
+    if (tokens <= 0) return
+
+    const model = sync.data.provider.find((item) => item.id === last.providerID)?.models[last.modelID]
+    const pct = model?.limit.context ? `${Math.round((tokens / model.limit.context) * 100)}%` : undefined
+    const cost = session()?.cost ?? 0
+
+    const money = new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+    })
+
+    return {
+      context: pct ? `${Locale.number(tokens)} (${pct})` : Locale.number(tokens),
+      cost: cost > 0 ? money.format(cost) : undefined,
+    }
+  })
+
+  const { theme } = useTheme()
+  const command = useCommandPalette()
+  const parentShortcut = useCommandShortcut("session.parent")
+  const previousShortcut = useCommandShortcut("session.child.previous")
+  const nextShortcut = useCommandShortcut("session.child.next")
+  const [hover, setHover] = createSignal<"parent" | "prev" | "next" | null>(null)
+  useTerminalDimensions()
+
+  return (
+    <box flexShrink={0}>
+      <box
+        paddingTop={1}
+        paddingBottom={1}
+        paddingLeft={2}
+        paddingRight={1}
+        {...SplitBorder}
+        border={["left"]}
+        borderColor={theme.border}
+        flexShrink={0}
+        backgroundColor={theme.backgroundPanel}
+      >
+        <box flexDirection="row" justifyContent="space-between" gap={1}>
+          <box flexDirection="row" gap={1}>
+            <text fg={theme.text}>
+              <b>{subagentInfo().label}</b>
+            </text>
+            <Show when={subagentInfo().total > 0}>
+              <text style={{ fg: theme.textMuted }}>
+                ({subagentInfo().index} of {subagentInfo().total})
+              </text>
+            </Show>
+            <Show when={usage()}>
+              {(item) => (
+                <text fg={theme.textMuted} wrapMode="none">
+                  {[item().context, item().cost].filter(Boolean).join(" · ")}
+                </text>
+              )}
+            </Show>
+          </box>
+          <box flexDirection="row" gap={2}>
+            <box
+              onMouseOver={() => setHover("parent")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => command.run("session.parent")}
+              backgroundColor={hover() === "parent" ? theme.backgroundElement : theme.backgroundPanel}
+            >
+              <text fg={theme.text}>
+                Parent <span style={{ fg: theme.textMuted }}>{parentShortcut()}</span>
+              </text>
+            </box>
+            <box
+              onMouseOver={() => setHover("prev")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => command.run("session.child.previous")}
+              backgroundColor={hover() === "prev" ? theme.backgroundElement : theme.backgroundPanel}
+            >
+              <text fg={theme.text}>
+                Prev <span style={{ fg: theme.textMuted }}>{previousShortcut()}</span>
+              </text>
+            </box>
+            <box
+              onMouseOver={() => setHover("next")}
+              onMouseOut={() => setHover(null)}
+              onMouseUp={() => command.run("session.child.next")}
+              backgroundColor={hover() === "next" ? theme.backgroundElement : theme.backgroundPanel}
+            >
+              <text fg={theme.text}>
+                Next <span style={{ fg: theme.textMuted }}>{nextShortcut()}</span>
+              </text>
+            </box>
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}

package/src/tui/run.ts

@@ -0,0 +1,84 @@
+/**
+ * APX TUI entry point.
+ * Usage: bun --preload @opentui/solid/preload src/tui/run.ts --pid <projectId> [--agent <name>] [--model <model>]
+ */
+import { tui } from "./app.tsx"
+import type { TuiConfig } from "./config/tui.ts"
+
+// ─── CLI argument parsing ────────────────────────────────────────────────────
+const args = process.argv.slice(2)
+function getFlag(flag: string): string | undefined {
+  const i = args.indexOf(flag)
+  return i !== -1 ? args[i + 1] : undefined
+}
+function hasFlag(flag: string): boolean {
+  return args.includes(flag)
+}
+
+const pid = getFlag("--pid") ?? ""
+const agent = getFlag("--agent")
+const model = getFlag("--model")
+const promptText = getFlag("--prompt")
+const sessionID = getFlag("--session")
+const continueSession = hasFlag("--continue") || hasFlag("-c")
+
+if (!pid) {
+  process.stderr.write("APX TUI requires --pid <projectId>\n")
+  process.exit(1)
+}
+
+const baseUrl = process.env.APX_URL ?? "http://127.0.0.1:7430"
+
+// ─── Minimal keybind lookup (no-op bindings, defaults are loaded by opentui) ─
+function createNoopKeybinds(): TuiConfig.Resolved["keybinds"] {
+  return {
+    get(_command: string) {
+      return []
+    },
+    gather(_name: string, _commands: readonly string[]) {
+      return []
+    },
+  }
+}
+
+// ─── Minimal resolved TUI config ─────────────────────────────────────────────
+let config: TuiConfig.Resolved
+
+try {
+  // Attempt to load the real config (may fail if opencode-core deps missing)
+  const { TuiConfig: TuiConfigModule } = await import("./config/tui.ts")
+  config = await TuiConfigModule.get()
+} catch {
+  // Fall back to safe minimal config
+  config = {
+    theme: undefined,
+    keybinds: createNoopKeybinds(),
+    plugin: [],
+    plugin_enabled: {},
+    leader_timeout: 2000,
+    scroll_speed: undefined,
+    scroll_acceleration: undefined,
+    diff_style: undefined,
+    mouse: true,
+    plugin_origins: [],
+  } as unknown as TuiConfig.Resolved
+}
+
+// ─── Launch TUI ──────────────────────────────────────────────────────────────
+await tui({
+  url: baseUrl,
+  pid,
+  agent,
+  model,
+  args: {
+    prompt: promptText,
+    continue: continueSession,
+    sessionID,
+    fork: false,
+    agent,
+    model,
+  },
+  config,
+})
+
+process.exit(0)

package/src/tui/thread.ts

@@ -0,0 +1,261 @@
+import { cmd } from "@/cli/cmd/cmd"
+import { Rpc } from "@/util/rpc"
+import { type rpc } from "./worker"
+import path from "path"
+import { fileURLToPath } from "url"
+import { UI } from "@/cli/ui"
+import * as Log from "@opencode-ai/core/util/log"
+import { errorMessage } from "@/util/error"
+import { withTimeout } from "@/util/timeout"
+import { withNetworkOptions, resolveNetworkOptionsNoConfig } from "@/cli/network"
+import { Filesystem } from "@/util/filesystem"
+import type { GlobalEvent } from "@opencode-ai/sdk/v2"
+import type { EventSource } from "./context/sdk"
+import { win32DisableProcessedInput, win32InstallCtrlCGuard } from "./win32"
+import { writeHeapSnapshot } from "v8"
+import { TuiConfig } from "./config/tui"
+import {
+  OPENCODE_PROCESS_ROLE,
+  OPENCODE_RUN_ID,
+  ensureRunID,
+  sanitizedProcessEnv,
+} from "@opencode-ai/core/util/opencode-process"
+import { validateSession } from "./validate-session"
+
+declare global {
+  const OPENCODE_WORKER_PATH: string
+}
+
+type RpcClient = ReturnType<typeof Rpc.client<typeof rpc>>
+
+function createWorkerFetch(client: RpcClient): typeof fetch {
+  const fn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const request = new Request(input, init)
+    const body = request.body ? await request.text() : undefined
+    const result = await client.call("fetch", {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body,
+    })
+    return new Response(result.body, {
+      status: result.status,
+      headers: result.headers,
+    })
+  }
+  return fn as typeof fetch
+}
+
+function createEventSource(client: RpcClient): EventSource {
+  return {
+    subscribe: async (handler) => {
+      return client.on<GlobalEvent>("global.event", (e) => {
+        handler(e)
+      })
+    },
+  }
+}
+
+async function target() {
+  if (typeof OPENCODE_WORKER_PATH !== "undefined") return OPENCODE_WORKER_PATH
+  const dist = new URL("./cli/cmd/tui/worker.js", import.meta.url)
+  if (await Filesystem.exists(fileURLToPath(dist))) return dist
+  return new URL("./worker.ts", import.meta.url)
+}
+
+async function input(value?: string) {
+  const piped = process.stdin.isTTY ? undefined : await Bun.stdin.text()
+  if (!value) return piped
+  if (!piped) return value
+  return piped + "\n" + value
+}
+
+export function resolveThreadDirectory(project?: string, envPWD = process.env.PWD, cwd = process.cwd()) {
+  const root = Filesystem.resolve(envPWD ?? cwd)
+  if (project) return Filesystem.resolve(path.isAbsolute(project) ? project : path.join(root, project))
+  return Filesystem.resolve(cwd)
+}
+
+export const TuiThreadCommand = cmd({
+  command: "$0 [project]",
+  describe: "start opencode tui",
+  builder: (yargs) =>
+    withNetworkOptions(yargs)
+      .positional("project", {
+        type: "string",
+        describe: "path to start opencode in",
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      })
+      .option("continue", {
+        alias: ["c"],
+        describe: "continue the last session",
+        type: "boolean",
+      })
+      .option("session", {
+        alias: ["s"],
+        type: "string",
+        describe: "session id to continue",
+      })
+      .option("fork", {
+        type: "boolean",
+        describe: "fork the session when continuing (use with --continue or --session)",
+      })
+      .option("prompt", {
+        type: "string",
+        describe: "prompt to use",
+      })
+      .option("agent", {
+        type: "string",
+        describe: "agent to use",
+      }),
+  handler: async (args) => {
+    // Keep ENABLE_PROCESSED_INPUT cleared even if other code flips it.
+    // (Important when running under `bun run` wrappers on Windows.)
+    const unguard = win32InstallCtrlCGuard()
+    try {
+      // Must be the very first thing — disables CTRL_C_EVENT before any Worker
+      // spawn or async work so the OS cannot kill the process group.
+      win32DisableProcessedInput()
+
+      if (args.fork && !args.continue && !args.session) {
+        UI.error("--fork requires --continue or --session")
+        process.exitCode = 1
+        return
+      }
+
+      // Resolve relative --project paths from PWD, then use the real cwd after
+      // chdir so the thread and worker share the same directory key.
+      const next = resolveThreadDirectory(args.project)
+      const file = await target()
+      try {
+        process.chdir(next)
+      } catch {
+        UI.error("Failed to change directory to " + next)
+        return
+      }
+      const cwd = Filesystem.resolve(process.cwd())
+      const env = sanitizedProcessEnv({
+        [OPENCODE_PROCESS_ROLE]: "worker",
+        [OPENCODE_RUN_ID]: ensureRunID(),
+      })
+
+      const worker = new Worker(file, {
+        env,
+      })
+      worker.onerror = (e) => {
+        Log.Default.error("thread error", {
+          message: e.message,
+          filename: e.filename,
+          lineno: e.lineno,
+          colno: e.colno,
+          error: e.error,
+        })
+      }
+
+      const client = Rpc.client<typeof rpc>(worker)
+      const error = (e: unknown) => {
+        Log.Default.error("process error", { error: errorMessage(e) })
+      }
+      const reload = () => {
+        client.call("reload", undefined).catch((err) => {
+          Log.Default.warn("worker reload failed", {
+            error: errorMessage(err),
+          })
+        })
+      }
+      process.on("uncaughtException", error)
+      process.on("unhandledRejection", error)
+      process.on("SIGUSR2", reload)
+
+      let stopped = false
+      const stop = async () => {
+        if (stopped) return
+        stopped = true
+        process.off("uncaughtException", error)
+        process.off("unhandledRejection", error)
+        process.off("SIGUSR2", reload)
+        await withTimeout(client.call("shutdown", undefined), 5000).catch((error) => {
+          Log.Default.warn("worker shutdown failed", {
+            error: errorMessage(error),
+          })
+        })
+        worker.terminate()
+      }
+
+      const prompt = await input(args.prompt)
+      const config = await TuiConfig.get()
+
+      const network = resolveNetworkOptionsNoConfig(args)
+      const external =
+        process.argv.includes("--port") ||
+        process.argv.includes("--hostname") ||
+        process.argv.includes("--mdns") ||
+        network.mdns ||
+        network.port !== 0 ||
+        network.hostname !== "127.0.0.1"
+
+      const transport = external
+        ? {
+            url: (await client.call("server", network)).url,
+            fetch: undefined,
+            events: undefined,
+          }
+        : {
+            url: "http://opencode.internal",
+            fetch: createWorkerFetch(client),
+            events: createEventSource(client),
+          }
+
+      try {
+        await validateSession({
+          url: transport.url,
+          sessionID: args.session,
+          directory: cwd,
+          fetch: transport.fetch,
+        })
+      } catch (error) {
+        UI.error(errorMessage(error))
+        process.exitCode = 1
+        return
+      }
+
+      setTimeout(() => {
+        client.call("checkUpgrade", { directory: cwd }).catch(() => {})
+      }, 1000).unref?.()
+
+      try {
+        const { tui } = await import("./app")
+        await tui({
+          url: transport.url,
+          async onSnapshot() {
+            const tui = writeHeapSnapshot("tui.heapsnapshot")
+            const server = await client.call("snapshot", undefined)
+            return [tui, server]
+          },
+          config,
+          directory: cwd,
+          fetch: transport.fetch,
+          events: transport.events,
+          args: {
+            continue: args.continue,
+            sessionID: args.session,
+            agent: args.agent,
+            model: args.model,
+            prompt,
+            fork: args.fork,
+          },
+        })
+      } finally {
+        await stop()
+      }
+    } finally {
+      unguard?.()
+    }
+    process.exit(0)
+  },
+})
+// scratch

package/src/tui/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "extends": "../../../tsconfig.cli.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "noEmit": true,
+    "types": [],
+    "paths": {
+      "@tui/*": ["./*"],
+      "@/cli/cmd/tui/*": ["./*"],
+      "@opencode-ai/sdk/v2": ["./_shims/opencode-sdk-v2.ts"],
+      "@opencode-ai/core/flag/flag": ["./_shims/core-flag.ts"],
+      "@opencode-ai/core/util/binary": ["./_shims/core-binary.ts"],
+      "@opencode-ai/core/util/log": ["./_shims/core-log.ts"],
+      "@opencode-ai/core/*": ["./_shims/core-any.ts"],
+      "@opencode-ai/plugin/tui": ["./_shims/plugin-tui.ts"],
+      "@opencode-ai/plugin/*": ["./_shims/opencode-any.ts"],
+      "@/session/session": ["./_shims/session-session.ts"],
+      "@/session/retry": ["./_shims/session-retry.ts"],
+      "@/session/schema": ["./_shims/session-schema.ts"],
+      "@/provider/provider": ["./_shims/provider-provider.ts"],
+      "@/snapshot": ["./_shims/snapshot.ts"],
+      "@/config/console-state": ["./_shims/config-console-state.ts"],
+      "@/cli/error": ["./_shims/cli-error.ts"],
+      "@/cli/logo": ["./_shims/cli-logo.ts"],
+      "@/cli/ui.ts": ["./_shims/cli-ui.ts"],
+      "@/cli/ui": ["./_shims/cli-ui.ts"],
+      "@/util/locale": ["./_shims/util-locale.ts"],
+      "@/util/error": ["./_shims/util-error.ts"],
+      "@/util/filesystem": ["./_shims/util-filesystem.ts"],
+      "@/util/iife": ["./_shims/util-iife.ts"],
+      "@/util/format": ["./_shims/util-format.ts"],
+      "@/util/process": ["./_shims/util-process.ts"],
+      "@/lsp/language": ["./_shims/lsp-language.ts"],
+      "@/tool/*": ["./_shims/tool-any.ts"],
+      "@/*": ["./_shims/opencode-any.ts"]
+    }
+  }
+}

package/src/tui/ui/dialog-alert.tsx

@@ -0,0 +1,66 @@
+import { TextAttributes } from "@opentui/core"
+import { useTheme } from "../context/theme"
+import { useDialog, type DialogContext } from "./dialog"
+import { useBindings } from "../keymap"
+
+export type DialogAlertProps = {
+  title: string
+  message: string
+  onConfirm?: () => void
+}
+
+export function DialogAlert(props: DialogAlertProps) {
+  const dialog = useDialog()
+  const { theme } = useTheme()
+
+  useBindings(() => ({
+    bindings: [
+      {
+        key: "return",
+        desc: "Confirm alert",
+        group: "Dialog",
+        cmd: () => {
+          props.onConfirm?.()
+          dialog.clear()
+        },
+      },
+    ],
+  }))
+  return (
+    <box paddingLeft={2} paddingRight={2} gap={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text attributes={TextAttributes.BOLD} fg={theme.text}>
+          {props.title}
+        </text>
+        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <box paddingBottom={1}>
+        <text fg={theme.textMuted}>{props.message}</text>
+      </box>
+      <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
+        <box
+          paddingLeft={3}
+          paddingRight={3}
+          backgroundColor={theme.primary}
+          onMouseUp={() => {
+            props.onConfirm?.()
+            dialog.clear()
+          }}
+        >
+          <text fg={theme.selectedListItemText}>ok</text>
+        </box>
+      </box>
+    </box>
+  )
+}
+
+DialogAlert.show = (dialog: DialogContext, title: string, message: string) => {
+  return new Promise<void>((resolve) => {
+    dialog.replace(
+      () => <DialogAlert title={title} message={message} onConfirm={() => resolve()} />,
+      () => resolve(),
+    )
+  })
+}

package/src/tui/ui/dialog-confirm.tsx

@@ -0,0 +1,108 @@
+import { TextAttributes } from "@opentui/core"
+import { useTheme } from "../context/theme"
+import { useDialog, type DialogContext } from "./dialog"
+import { createStore } from "solid-js/store"
+import { For } from "solid-js"
+import { Locale } from "@/util/locale"
+import { useBindings } from "../keymap"
+
+export type DialogConfirmProps = {
+  title: string
+  message: string
+  onConfirm?: () => void
+  onCancel?: () => void
+  label?: string
+}
+
+export type DialogConfirmResult = boolean | undefined
+
+export function DialogConfirm(props: DialogConfirmProps) {
+  const dialog = useDialog()
+  const { theme } = useTheme()
+  const [store, setStore] = createStore({
+    active: "confirm" as "confirm" | "cancel",
+  })
+
+  useBindings(() => ({
+    bindings: [
+      {
+        key: "return",
+        desc: "Confirm dialog selection",
+        group: "Dialog",
+        cmd: () => {
+          if (store.active === "confirm") props.onConfirm?.()
+          if (store.active === "cancel") props.onCancel?.()
+          dialog.clear()
+        },
+      },
+      {
+        key: "left",
+        desc: "Previous dialog option",
+        group: "Dialog",
+        cmd: () => {
+          setStore("active", store.active === "confirm" ? "cancel" : "confirm")
+        },
+      },
+      {
+        key: "right",
+        desc: "Next dialog option",
+        group: "Dialog",
+        cmd: () => {
+          setStore("active", store.active === "confirm" ? "cancel" : "confirm")
+        },
+      },
+    ],
+  }))
+  return (
+    <box paddingLeft={2} paddingRight={2} gap={1}>
+      <box flexDirection="row" justifyContent="space-between">
+        <text attributes={TextAttributes.BOLD} fg={theme.text}>
+          {props.title}
+        </text>
+        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <box paddingBottom={1}>
+        <text fg={theme.textMuted}>{props.message}</text>
+      </box>
+      <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
+        <For each={["cancel", "confirm"] as const}>
+          {(key) => (
+            <box
+              paddingLeft={1}
+              paddingRight={1}
+              backgroundColor={key === store.active ? theme.primary : undefined}
+              onMouseUp={() => {
+                if (key === "confirm") props.onConfirm?.()
+                if (key === "cancel") props.onCancel?.()
+                dialog.clear()
+              }}
+            >
+              <text fg={key === store.active ? theme.selectedListItemText : theme.textMuted}>
+                {Locale.titlecase(key === "cancel" ? (props.label ?? key) : key)}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+    </box>
+  )
+}
+
+DialogConfirm.show = (dialog: DialogContext, title: string, message: string, label?: string) => {
+  return new Promise<DialogConfirmResult>((resolve) => {
+    dialog.replace(
+      () => (
+        <DialogConfirm
+          title={title}
+          message={message}
+          onConfirm={() => resolve(true)}
+          onCancel={() => resolve(false)}
+          label={label}
+        />
+      ),
+      () => resolve(undefined),
+    )
+  })
+}