@agentprojectcontext/apx 1.15.6 → 1.17.0

package/src/tui/context/prompt.tsx

@@ -0,0 +1,18 @@
+import { createSimpleContext } from "./helper"
+import type { PromptRef } from "../component/prompt"
+
+export const { use: usePromptRef, provider: PromptRefProvider } = createSimpleContext({
+  name: "PromptRef",
+  init: () => {
+    let current: PromptRef | undefined
+
+    return {
+      get current() {
+        return current
+      },
+      set(ref: PromptRef | undefined) {
+        current = ref
+      },
+    }
+  },
+})

package/src/tui/context/route.tsx

@@ -0,0 +1,52 @@
+import { createStore, reconcile } from "solid-js/store"
+import { createSimpleContext } from "./helper"
+import type { PromptInfo } from "../component/prompt/history"
+
+export type HomeRoute = {
+  type: "home"
+  prompt?: PromptInfo
+}
+
+export type SessionRoute = {
+  type: "session"
+  sessionID: string
+  prompt?: PromptInfo
+}
+
+export type PluginRoute = {
+  type: "plugin"
+  id: string
+  data?: Record<string, unknown>
+}
+
+export type Route = HomeRoute | SessionRoute | PluginRoute
+
+export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
+  name: "Route",
+  init: (props: { initialRoute?: Route }) => {
+    const [store, setStore] = createStore<Route>(
+      props.initialRoute ??
+        (process.env["OPENCODE_ROUTE"]
+          ? JSON.parse(process.env["OPENCODE_ROUTE"])
+          : {
+              type: "home",
+            }),
+    )
+
+    return {
+      get data() {
+        return store
+      },
+      navigate(route: Route) {
+        setStore(reconcile(route))
+      },
+    }
+  },
+})
+
+export type RouteContext = ReturnType<typeof useRoute>
+
+export function useRouteData<T extends Route["type"]>(type: T) {
+  const route = useRoute()
+  return route.data as Extract<Route, { type: typeof type }>
+}

package/src/tui/context/sdk-apx.tsx

@@ -0,0 +1,185 @@
+import { createGlobalEmitter } from "@solid-primitives/event-bus"
+import { createSimpleContext } from "./helper"
+import { onCleanup } from "solid-js"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+const TOKEN_PATH = path.join(os.homedir(), ".apx", "daemon.token")
+
+function readToken(): string {
+  try {
+    return fs.readFileSync(TOKEN_PATH, "utf8").trim()
+  } catch {
+    return ""
+  }
+}
+
+export type ApxEvent =
+  | { type: "session.created"; sessionID: string }
+  | { type: "chunk"; sessionID: string; chunk: string }
+  | { type: "final"; sessionID: string; text: string; usage?: { input_tokens: number; output_tokens: number } }
+  | { type: "error"; sessionID: string; error: string }
+
+export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
+  name: "SDK",
+  init: (props: {
+    url: string
+    pid: string
+    agent?: string
+    model?: string
+    // Legacy compat props (unused but accepted to avoid prop errors)
+    directory?: string
+    fetch?: typeof fetch
+    headers?: RequestInit["headers"]
+    events?: unknown
+  }) => {
+    const abort = new AbortController()
+    const emitter = createGlobalEmitter<{ event: ApxEvent }>()
+
+    function headers(): Record<string, string> {
+      const token = readToken()
+      return {
+        "content-type": "application/json",
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      }
+    }
+
+    async function streamChat(
+      sessionID: string,
+      prompt: string,
+      previousMessages: Array<{ role: string; content: string }> = [],
+    ) {
+      const res = await fetch(`${props.url}/projects/${props.pid}/super-agent/chat/stream`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ prompt, model: props.model, previousMessages }),
+        signal: abort.signal,
+      })
+      if (!res.ok || !res.body) throw new Error(`stream error: ${res.status}`)
+      const reader = res.body.getReader()
+      const dec = new TextDecoder()
+      let buf = ""
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buf += dec.decode(value, { stream: true })
+        const lines = buf.split(/\r?\n/)
+        buf = lines.pop() ?? ""
+        for (const line of lines) {
+          if (!line.trim()) continue
+          try {
+            const ev = JSON.parse(line)
+            if (ev.type === "chunk") emitter.emit("event", { type: "chunk", sessionID, chunk: ev.chunk })
+            if (ev.type === "final")
+              emitter.emit("event", {
+                type: "final",
+                sessionID,
+                text: ev.result?.text ?? "",
+                usage: ev.result?.usage,
+              })
+            if (ev.type === "error") emitter.emit("event", { type: "error", sessionID, error: ev.error })
+          } catch {
+            // ignore parse errors for partial lines
+          }
+        }
+      }
+    }
+
+    async function createSession(): Promise<string> {
+      const token = readToken()
+      const res = await fetch(`${props.url}/projects/${props.pid}/sessions`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify({}),
+        signal: abort.signal,
+      })
+      if (!res.ok) throw new Error(`createSession: ${res.status}`)
+      const data = await res.json()
+      return (data as any).id as string
+    }
+
+    async function listSessions(): Promise<Array<{ id: string; title: string; updatedAt?: number }>> {
+      try {
+        const token = readToken()
+        const res = await fetch(`${props.url}/projects/${props.pid}/sessions`, {
+          headers: token ? { authorization: `Bearer ${token}` } : {},
+          signal: abort.signal,
+        })
+        if (!res.ok) return []
+        const data = await res.json()
+        return Array.isArray(data) ? data : []
+      } catch {
+        return []
+      }
+    }
+
+    onCleanup(() => abort.abort())
+
+    // Recursive Proxy: any sdk.client.X.Y.Z() call returns { data: [] } instead of crashing.
+    function makeProxy(overrides: Record<string, any> = {}): any {
+      const stub = async () => ({ data: [] })
+      return new Proxy(stub, {
+        get(_target, prop: string) {
+          if (prop in overrides) return overrides[prop]
+          return makeProxy()
+        },
+        apply(_target, _this, args) {
+          // Check if any override matches this call pattern
+          return Promise.resolve({ data: [] })
+        },
+      })
+    }
+
+    const client = makeProxy({
+      session: makeProxy({
+        createSession,
+        listSessions,
+        streamChat,
+        create: async (_opts: any) => ({ data: { id: await createSession() } }),
+        list: async (_opts: any) => ({ data: await listSessions() }),
+        get: async (_opts: any) => ({ data: undefined }),
+        delete: async (_opts: any) => ({ data: undefined }),
+        fork: async (_opts: any) => ({ data: undefined, error: new Error("not supported") }),
+        abort: async (_opts: any) => {},
+        prompt: async (_opts: any) => {},
+        shell: async (_opts: any) => {},
+        command: async (_opts: any) => {},
+        refresh: async () => {},
+        update: async (_opts: any) => ({ data: undefined }),
+        messages: async (_opts: any) => ({ data: [] }),
+        todo: async (_opts: any) => ({ data: [] }),
+        diff: async (_opts: any) => ({ data: [] }),
+        status: async (_opts: any) => ({ data: {} }),
+      }),
+      path: makeProxy({
+        get: async (_opts?: any) => ({
+          data: { home: "", state: "", config: "", worktree: "", directory: process.cwd() },
+        }),
+      }),
+      project: makeProxy({
+        current: async (_opts?: any) => ({ data: { id: props.pid } }),
+      }),
+      global: makeProxy({
+        upgrade: async (_opts: any) => ({ data: undefined, error: new Error("not supported") }),
+      }),
+    })
+
+    return {
+      url: props.url,
+      pid: props.pid,
+      agent: props.agent ?? "super-agent",
+      model: props.model ?? "claude-3-5-sonnet",
+      // Legacy opencode compat
+      directory: props.directory ?? process.cwd(),
+      event: emitter,
+      client,
+      streamChat,
+      createSession,
+      listSessions,
+    }
+  },
+})

package/src/tui/context/sdk.tsx

@@ -0,0 +1,6 @@
+/**
+ * APX compatibility shim for the opencode SDK context.
+ * Re-exports from sdk-apx.tsx so existing imports continue to work.
+ */
+export type { ApxEvent as EventSource } from "./sdk-apx"
+export { useSDK, SDKProvider } from "./sdk-apx"

package/src/tui/context/sync-apx.tsx

@@ -0,0 +1,178 @@
+import { createStore, produce, reconcile } from "solid-js/store"
+import { batch, onMount } from "solid-js"
+import { createSimpleContext } from "./helper"
+import { useSDK } from "./sdk-apx"
+import type { ApxEvent } from "./sdk-apx"
+
+export type ApxSession = {
+  id: string
+  title: string
+  updatedAt?: number
+}
+
+export type ApxMessage = {
+  id: string
+  sessionID: string
+  role: "user" | "assistant"
+  text: string
+  streaming?: boolean
+  error?: boolean
+}
+
+export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContext({
+  name: "ApxSync",
+  init: () => {
+    const sdk = useSDK()
+
+    const [store, setStore] = createStore<{
+      status: "loading" | "ready"
+      sessions: ApxSession[]
+      messages: Record<string, ApxMessage[]>
+      currentSessionID: string | undefined
+      previousMessages: Array<{ role: string; content: string }>
+    }>({
+      status: "loading",
+      sessions: [],
+      messages: {},
+      currentSessionID: undefined,
+      previousMessages: [],
+    })
+
+    // Listen to APX stream events
+    sdk.event.on("event", (ev: ApxEvent) => {
+      if (ev.type === "chunk") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = (draft[e.sessionID] ??= [])
+            const last = msgs[msgs.length - 1]
+            if (last?.role === "assistant" && last.streaming) {
+              last.text += e.chunk
+            } else {
+              msgs.push({
+                id: `msg-${Date.now()}`,
+                sessionID: e.sessionID,
+                role: "assistant",
+                text: e.chunk,
+                streaming: true,
+              })
+            }
+          }),
+        )
+      }
+
+      if (ev.type === "final") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = (draft[e.sessionID] ??= [])
+            const last = msgs[msgs.length - 1]
+            if (last?.role === "assistant") {
+              last.text = e.text
+              last.streaming = false
+            }
+          }),
+        )
+        setStore("previousMessages", (prev) => [...prev, { role: "assistant", content: e.text }])
+      }
+
+      if (ev.type === "error") {
+        const e = ev
+        setStore(
+          "messages",
+          produce((draft) => {
+            const msgs = (draft[e.sessionID] ??= [])
+            const last = msgs[msgs.length - 1]
+            if (last?.role === "assistant" && last.streaming) {
+              last.streaming = false
+              last.error = true
+            } else {
+              msgs.push({
+                id: `err-${Date.now()}`,
+                sessionID: e.sessionID,
+                role: "assistant",
+                text: e.error,
+                streaming: false,
+                error: true,
+              })
+            }
+          }),
+        )
+      }
+    })
+
+    async function loadSessions() {
+      const list = await sdk.listSessions()
+      setStore("sessions", reconcile(list))
+    }
+
+    async function ensureSession(): Promise<string> {
+      if (store.currentSessionID) return store.currentSessionID
+      const id = await sdk.createSession()
+      setStore("currentSessionID", id)
+      setStore(
+        "sessions",
+        produce((draft) => {
+          draft.unshift({ id, title: "New session" })
+        }),
+      )
+      return id
+    }
+
+    async function sendMessage(text: string) {
+      const sessionID = await ensureSession()
+      const userMsg: ApxMessage = {
+        id: `user-${Date.now()}`,
+        sessionID,
+        role: "user",
+        text,
+      }
+      batch(() => {
+        setStore(
+          "messages",
+          produce((draft) => {
+            ;(draft[sessionID] ??= []).push(userMsg)
+          }),
+        )
+        setStore("previousMessages", (prev) => [...prev, { role: "user", content: text }])
+      })
+      await sdk.streamChat(sessionID, text, store.previousMessages.slice(-20))
+    }
+
+    onMount(() => {
+      void loadSessions().finally(() => setStore("status", "ready"))
+    })
+
+    return {
+      data: store,
+      get status() {
+        return store.status
+      },
+      get ready() {
+        return store.status === "ready"
+      },
+      session: {
+        get(sessionID: string) {
+          return store.sessions.find((s) => s.id === sessionID)
+        },
+        list() {
+          return store.sessions
+        },
+        current() {
+          return store.currentSessionID
+        },
+        setCurrent(id: string) {
+          setStore("currentSessionID", id)
+        },
+        messages(sessionID: string) {
+          return store.messages[sessionID] ?? []
+        },
+        async refresh() {},
+      },
+      sendMessage,
+      ensureSession,
+    }
+  },
+})

package/src/tui/context/sync-v2.tsx

@@ -0,0 +1,16 @@
+/**
+ * APX compatibility shim for sync-v2.tsx.
+ * The original file tracked opencode-specific V2 session messages.
+ * For APX we don't need it — provide a no-op provider.
+ */
+import { createContext, useContext, type ParentProps } from "solid-js"
+
+const ctx = createContext<Record<string, never>>({})
+
+export function SyncProviderV2(props: ParentProps) {
+  return <ctx.Provider value={{}}>{props.children}</ctx.Provider>
+}
+
+export function useSyncV2() {
+  return useContext(ctx)
+}

package/src/tui/context/sync.tsx

@@ -0,0 +1,118 @@
+/**
+ * APX compatibility shim for the opencode Sync context.
+ *
+ * This file replaces the original opencode sync.tsx with a version that delegates
+ * to the APX sync context (sync-apx.tsx) while providing the same interface shape
+ * that other TUI components expect.
+ */
+import { createSimpleContext } from "./helper"
+import { useApxSync } from "./sync-apx"
+import { onMount } from "solid-js"
+
+// Re-export useApxSync as useSync for compatibility
+export const { use: useSync, provider: SyncProvider } = createSimpleContext({
+  name: "Sync",
+  init: () => {
+    const apx = useApxSync()
+
+    onMount(() => {
+      // APX sync already loads sessions in its own onMount
+    })
+
+    // Return a compatible object that matches the shape expected by existing TUI components
+    return {
+      data: {
+        get status() {
+          return apx.status
+        },
+        // Provider fields (APX has no providers — return stubs)
+        provider: [] as any[],
+        provider_default: {} as Record<string, string>,
+        provider_next: { all: [], default: {}, connected: [] } as any,
+        provider_auth: {} as Record<string, any[]>,
+        console_state: { switchableOrgCount: 0 } as any,
+        // Agent fields — empty for APX (agent is configured via CLI args)
+        agent: [] as any[],
+        command: [] as any[],
+        // Session-related — delegate to APX
+        get session() {
+          return apx.session.list().map((s: any) => ({
+            ...s,
+            time: { updated: s.updatedAt ?? Date.now(), compacting: false },
+            cost: 0,
+            workspaceID: undefined,
+            parentID: undefined,
+          }))
+        },
+        session_status: {} as Record<string, any>,
+        session_diff: {} as Record<string, any[]>,
+        // Messages — delegate to APX
+        get message() {
+          return apx.data.messages as Record<string, any[]>
+        },
+        messages: {} as Record<string, any[]>,
+        part: {} as Record<string, any[]>,
+        // Permission/question stubs
+        permission: {} as Record<string, any[]>,
+        question: {} as Record<string, any[]>,
+        todo: {} as Record<string, any[]>,
+        // Config stub
+        config: {
+          experimental: {
+            disable_paste_summary: false,
+          },
+          model: undefined,
+          plugin: [],
+          reference: [],
+          share: undefined,
+        } as any,
+        // LSP/MCP stubs
+        lsp: [] as any[],
+        mcp: {} as Record<string, any>,
+        mcp_resource: {} as Record<string, any>,
+        formatter: [] as any[],
+        vcs: undefined as any,
+      },
+
+      get status() {
+        return apx.status === "ready" ? "complete" : apx.status === "loading" ? "loading" : "partial"
+      },
+
+      get ready() {
+        return apx.ready
+      },
+
+      session: {
+        get(sessionID: string) {
+          const s = apx.session.get(sessionID)
+          if (!s) return undefined
+          return {
+            ...s,
+            time: { updated: s.updatedAt ?? Date.now(), compacting: false },
+            cost: 0,
+            workspaceID: undefined,
+            parentID: undefined,
+          }
+        },
+        query() {
+          return {}
+        },
+        async refresh() {
+          await apx.session.refresh()
+        },
+        status(_sessionID: string) {
+          return "idle" as const
+        },
+        async sync(_sessionID: string) {},
+      },
+
+      async bootstrap() {},
+
+      // Path info for autocomplete and other components
+      path: {
+        directory: process.cwd(),
+        worktree: process.cwd(),
+      },
+    }
+  },
+})

package/src/tui/context/theme/aura.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "darkBg": "#0f0f0f",
+    "darkBgPanel": "#15141b",
+    "darkBorder": "#2d2d2d",
+    "darkFgMuted": "#6d6d6d",
+    "darkFg": "#edecee",
+    "purple": "#a277ff",
+    "pink": "#f694ff",
+    "blue": "#82e2ff",
+    "red": "#ff6767",
+    "orange": "#ffca85",
+    "cyan": "#61ffca",
+    "green": "#9dff65"
+  },
+  "theme": {
+    "primary": "purple",
+    "secondary": "pink",
+    "accent": "purple",
+    "error": "red",
+    "warning": "orange",
+    "success": "cyan",
+    "info": "purple",
+    "text": "darkFg",
+    "textMuted": "darkFgMuted",
+    "background": "darkBg",
+    "backgroundPanel": "darkBgPanel",
+    "backgroundElement": "darkBgPanel",
+    "border": "darkBorder",
+    "borderActive": "darkFgMuted",
+    "borderSubtle": "darkBorder",
+    "diffAdded": "cyan",
+    "diffRemoved": "red",
+    "diffContext": "darkFgMuted",
+    "diffHunkHeader": "darkFgMuted",
+    "diffHighlightAdded": "cyan",
+    "diffHighlightRemoved": "red",
+    "diffAddedBg": "#354933",
+    "diffRemovedBg": "#3f191a",
+    "diffContextBg": "darkBgPanel",
+    "diffLineNumber": "#898989",
+    "diffAddedLineNumberBg": "#162620",
+    "diffRemovedLineNumberBg": "#26161a",
+    "markdownText": "darkFg",
+    "markdownHeading": "purple",
+    "markdownLink": "pink",
+    "markdownLinkText": "purple",
+    "markdownCode": "cyan",
+    "markdownBlockQuote": "darkFgMuted",
+    "markdownEmph": "orange",
+    "markdownStrong": "purple",
+    "markdownHorizontalRule": "darkFgMuted",
+    "markdownListItem": "purple",
+    "markdownListEnumeration": "purple",
+    "markdownImage": "pink",
+    "markdownImageText": "purple",
+    "markdownCodeBlock": "darkFg",
+    "syntaxComment": "darkFgMuted",
+    "syntaxKeyword": "pink",
+    "syntaxFunction": "purple",
+    "syntaxVariable": "purple",
+    "syntaxString": "cyan",
+    "syntaxNumber": "green",
+    "syntaxType": "purple",
+    "syntaxOperator": "pink",
+    "syntaxPunctuation": "darkFg"
+  }
+}