@agentprojectcontext/apx 1.20.0 → 1.22.0

package/src/cli/index.js

@@ -32,6 +32,7 @@ import {
   cmdSessionResume,
   cmdSessionCompact,
 } from "./commands/session.js";
+import { cmdSessionsList } from "./commands/sessions.js";
 import {
   cmdMcpList,
   cmdMcpAdd,
@@ -482,6 +483,45 @@ const HELP_TOPICS = new Map(Object.entries({
     ],
     examples: ["apx session compact reviewer --conversation abc123"],
   }),
+  sessions: topic({
+    title: "apx sessions",
+    summary: "List AI engine sessions (Claude Code, Codex, APX) non-interactively.",
+    usage: ["apx sessions list [--engine <id>] [--project <name>|--dir <path>] [--limit N]"],
+    commands: [
+      ["list | ls", "List engine projects, or sessions of one project."],
+    ],
+    options: [
+      ["--engine <id>", "apx (default) | claude | codex | antigravity."],
+      ["--project <name>", "A registered APX project to resolve the directory from."],
+      ["--dir <path>", "An explicit project directory (for unregistered projects)."],
+      ["--limit N", "Show only the N most recent sessions."],
+    ],
+    examples: [
+      "apx sessions list --engine claude",
+      "apx sessions list --engine claude --project iacrmar",
+      "apx sessions list --engine codex --dir /path/to/project",
+    ],
+  }),
+  "sessions list": topic({
+    title: "apx sessions list",
+    summary: "List engine projects, or the sessions of one resolved project.",
+    usage: [
+      "apx sessions list [--engine <id>]",
+      "apx sessions list --engine <id> --project <name>",
+      "apx sessions list --engine <id> --dir <path>",
+    ],
+    options: [
+      ["--engine <id>", "apx (default) | claude | codex | antigravity."],
+      ["--project <name>", "Resolve directory from a registered APX project."],
+      ["--dir <path>", "Explicit project directory."],
+      ["--limit N", "Show only the N most recent sessions."],
+    ],
+    examples: [
+      "apx sessions list",
+      "apx sessions list --engine claude --project iacrmar",
+      "apx sessions list --engine codex --dir /Volumes/work/iacrmar",
+    ],
+  }),
   mcp: topic({
     title: "apx mcp",
     summary: "Manage and call MCP servers merged from APC and supported IDE configs.",
@@ -1049,6 +1089,7 @@ const HELP_ALIASES = new Map(Object.entries({
   "agent vault ls": "agent vault list",
   "session ls": "session list",
   "session show": "session get",
+  "sessions ls": "sessions list",
   "mcp ls": "mcp list",
   "mcp rm": "mcp remove",
   "conv list": "conversations list",
@@ -1140,6 +1181,7 @@ function buildHelp(version) {
     hCmd("apx session close-stale",    36, "auto-close sessions older than 1h"),
     hCmd("apx session resume <id>",    36, "--summary  --full  (APC + Claude Code transcript)"),
     hCmd("apx session compact <slug>", 36, "--conversation <id>  collapse history into summary"),
+    hCmd("apx sessions list",          36, "list AI engine sessions  --engine claude|codex|apx  --project P | --dir D"),
 
     hSec("MCPs"),
     hCmd("apx mcp list",               36, ""),
@@ -1426,6 +1468,15 @@ async function dispatch(cmd, rest) {
         break;
       }
 
+      case "sessions": {
+        const sub = rest[0];
+        const isListSub = sub === "list" || sub === "ls";
+        const a = parseArgs(isListSub ? rest.slice(1) : rest);
+        if (!sub || isListSub || sub.startsWith("--")) cmdSessionsList(a);
+        else die(`unknown sessions subcommand: ${sub} — try: list`);
+        break;
+      }
+
       case "mcp": {
         const sub = rest[0];
         const a = parseArgs(rest.slice(1));

package/src/core/runtime-skills/claude-code.md

@@ -53,6 +53,23 @@ For high-trust automation in an already sandboxed environment:
 claude -p "task" --permission-mode bypassPermissions --output-format json
 ```
 
+## List and resume sessions
+
+Claude Code has no `--list`; `--resume` is always an interactive picker. To list
+sessions non-interactively, use APX:
+
+```bash
+apx sessions list --engine claude --project <name>   # registered APX project
+apx sessions list --engine claude --dir <path>       # any directory
+```
+
+This prints each session's id and title. To resume one (run from the project directory):
+
+```bash
+claude --continue                       # most recent session
+claude -p --resume <session-id> "..."   # specific session, always with -p (print mode)
+```
+
 ## APX runtime
 
 Run a project agent through Claude Code:

package/src/core/runtime-skills/codex-cli.md

@@ -60,6 +60,23 @@ codex exec --json --sandbox workspace-write --skip-git-repo-check "task"
 `--skip-git-repo-check` matters for APX default runtime dirs such as `~/.apx/projects/default`,
 which may not be Git repositories.
 
+## List and resume sessions
+
+List Codex sessions for a project non-interactively with APX:
+
+```bash
+apx sessions list --engine codex --project <name>   # registered APX project
+apx sessions list --engine codex --dir <path>       # any directory
+```
+
+Resume a session:
+
+```bash
+codex resume <session-id>                  # interactive
+codex exec resume <session-id> "..."       # non-interactive
+codex resume --last                        # most recent session
+```
+
 ## APX runtime
 
 Run a project agent through Codex:

package/src/tui/_shims/cli-logo.ts

@@ -2,17 +2,19 @@ export type LogoShape = { left: string[]; right: string[] }
 
 export const logo: LogoShape = {
   left: [
-    "   _    ___ __  __",
-    "  /_\\  | _ \\\\ \\/ /",
-    " / _ \\ |  _/ >  < ",
-    "/_/ \\_\\|_|  /_/\\_\\",
+    "              ",
+    "█▀▀█ █▀▀█ █▄▄█",
+    "█^^█ █__█ _██_",
+    "█__█ █▀▀▀ █▀▀█",
   ],
   right: [
-    "  ___   ___   ___   ___ ",
-    " / __| / _ \\ |   \\ | __|",
-    "| (__ | (_) || |) || _| ",
-    " \\___| \\___/ |___/ |___|",
+    "             ▄     ",
+    "█▀▀▀ █▀▀█ █▀▀█ █▀▀█",
+    "█___ █__█ █__█ █^^^",
+    "▀▀▀▀ ▀▀▀▀ ▀▀▀▀ ▀▀▀▀",
   ],
 }
 
 export const go = logo
+
+export const marks = "_^~,"

package/src/tui/_shims/opencode-any.ts

@@ -96,8 +96,8 @@ export const cmd: any = {}
 export const withTimeout: any = (fn: any) => fn
 export const withNetworkOptions: any = () => {}
 export const resolveNetworkOptionsNoConfig: any = () => ({})
-export const displayCharAt: any = () => ""
-export const mentionTriggerIndex: any = () => -1
+export const displayCharAt: any = () => undefined
+export const mentionTriggerIndex: any = () => undefined
 export const installPlugin: any = () => {}
 export const patchPluginConfig: any = () => {}
 export const readPluginManifest: any = () => ({})

package/src/tui/_shims/prompt-display.ts

@@ -0,0 +1,45 @@
+// Shim for opencode's `@/cli/cmd/prompt-display`.
+// Ported verbatim from opencode so the prompt autocomplete behaves correctly:
+// the catch-all shim used to stub `mentionTriggerIndex` as `() => -1`, which is
+// `!== undefined` and therefore opened the "@" autocomplete on every keystroke,
+// swallowing Enter / Tab / Ctrl+P.
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
+
+function displayOffsetIndex(value: string, offset: number) {
+  if (offset <= 0) return 0
+
+  let width = 0
+  for (const part of graphemes.segment(value)) {
+    const next = width + Bun.stringWidth(part.segment)
+    if (next > offset) return part.index
+    width = next
+  }
+
+  return value.length
+}
+
+export function displaySlice(value: string, start = 0, end = Bun.stringWidth(value)) {
+  return value.slice(displayOffsetIndex(value, start), displayOffsetIndex(value, end))
+}
+
+export function displayCharAt(value: string, offset: number) {
+  let width = 0
+  for (const part of graphemes.segment(value)) {
+    const next = width + Bun.stringWidth(part.segment)
+    if (offset === width || offset < next) return part.segment
+    width = next
+  }
+}
+
+export function mentionTriggerIndex(value: string, offset = Bun.stringWidth(value)) {
+  const text = displaySlice(value, 0, offset)
+  const index = text.lastIndexOf("@")
+  if (index === -1) return
+
+  const before = index === 0 ? undefined : text[index - 1]
+  const query = text.slice(index)
+  if ((before === undefined || /\s/.test(before)) && !/\s/.test(query)) {
+    return Bun.stringWidth(text.slice(0, index))
+  }
+}

package/src/tui/_shims/util-locale.ts

@@ -1,10 +1,104 @@
+// Shim for opencode's `@/util/locale`.
+// Ported verbatim from opencode — the previous stub was missing `truncate`,
+// `truncateLeft`, `time`, `datetime`, `duration`, etc., which crashed the
+// command palette dialog (`Locale.truncate is not a function`).
+
+function titlecase(str: string) {
+  return str.replace(/\b\w/g, (c) => c.toUpperCase())
+}
+
+function time(input: number): string {
+  const date = new Date(input)
+  return date.toLocaleTimeString(undefined, { timeStyle: "short" })
+}
+
+function datetime(input: number): string {
+  const date = new Date(input)
+  const localTime = time(input)
+  const localDate = date.toLocaleDateString()
+  return `${localTime} · ${localDate}`
+}
+
+function todayTimeOrDateTime(input: number): string {
+  const date = new Date(input)
+  const now = new Date()
+  const isToday =
+    date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
+
+  if (isToday) {
+    return time(input)
+  } else {
+    return datetime(input)
+  }
+}
+
+function number(num: number): string {
+  if (num >= 1000000) {
+    return (num / 1000000).toFixed(1) + "M"
+  } else if (num >= 1000) {
+    return (num / 1000).toFixed(1) + "K"
+  }
+  return num.toString()
+}
+
+function duration(input: number) {
+  if (input < 1000) {
+    return `${input}ms`
+  }
+  if (input < 60000) {
+    return `${(input / 1000).toFixed(1)}s`
+  }
+  if (input < 3600000) {
+    const minutes = Math.floor(input / 60000)
+    const seconds = Math.floor((input % 60000) / 1000)
+    return `${minutes}m ${seconds}s`
+  }
+  if (input < 86400000) {
+    const hours = Math.floor(input / 3600000)
+    const minutes = Math.floor((input % 3600000) / 60000)
+    return `${hours}h ${minutes}m`
+  }
+  const hours = Math.floor(input / 3600000)
+  const days = Math.floor((input % 3600000) / 86400000)
+  return `${days}d ${hours}h`
+}
+
+function truncate(str: string, len: number): string {
+  if (str.length <= len) return str
+  return str.slice(0, len - 1) + "…"
+}
+
+function truncateLeft(str: string, len: number): string {
+  if (str.length <= len) return str
+  return "…" + str.slice(-(len - 1))
+}
+
+function truncateMiddle(str: string, maxLength: number = 35): string {
+  if (str.length <= maxLength) return str
+
+  const ellipsis = "…"
+  const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
+  const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
+
+  return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
+}
+
+function pluralize(count: number, singular: string, plural: string): string {
+  const template = count === 1 ? singular : plural
+  return template.replace("{}", count.toString())
+}
+
 export const Locale = {
+  titlecase,
+  time,
+  datetime,
+  todayTimeOrDateTime,
+  number,
+  duration,
+  truncate,
+  truncateLeft,
+  truncateMiddle,
+  pluralize,
+  // legacy alias kept for any callers expecting `format`
   format: (n: number) => String(n),
-  number: (n: number) => n.toLocaleString(),
-  titlecase: (s: string) => s.charAt(0).toUpperCase() + s.slice(1),
-  truncateMiddle: (s: string, maxLen: number): string => {
-    if (s.length <= maxLen) return s
-    const half = Math.floor((maxLen - 3) / 2)
-    return s.slice(0, half) + "..." + s.slice(s.length - half)
-  },
 }

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

@@ -18,6 +18,7 @@ function readToken(): string {
 
 export type ApxEvent =
   | { type: "session.created"; sessionID: string }
+  | { type: "user"; sessionID: string; text: 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 }
@@ -54,13 +55,29 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       prompt: string,
       previousMessages: Array<{ role: string; content: string }> = [],
     ) {
+      // Do NOT send `model` — the super-agent owns its model (configured at the
+      // system level in ~/.apx/config.json). Overriding it from the TUI would
+      // bypass that single source of truth. `props.model` is kept only for
+      // display in the sidebar.
       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 }),
+        body: JSON.stringify({ prompt, previousMessages }),
         signal: abort.signal,
       })
-      if (!res.ok || !res.body) throw new Error(`stream error: ${res.status}`)
+      if (!res.ok || !res.body) {
+        // Surface the daemon's actual error message (e.g. {"error":"project not found"})
+        // instead of a bare status code.
+        let detail = ""
+        try {
+          const body = await res.text()
+          const parsed = JSON.parse(body)
+          detail = parsed?.error ?? body
+        } catch {
+          /* non-JSON / empty body */
+        }
+        throw new Error(detail ? `${detail} (HTTP ${res.status})` : `stream error: ${res.status}`)
+      }
       const reader = res.body.getReader()
       const dec = new TextDecoder()
       let buf = ""
@@ -90,20 +107,11 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
       }
     }
 
+    // The APX daemon has no generic "create session" route — a chat turn is
+    // streamed directly through /super-agent/chat/stream. The TUI still needs a
+    // stable session id to group messages, so we mint one locally.
     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
+      return `apx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
     }
 
     function runShell(sessionID: string, command: string, cwd: string = process.cwd()): Promise<{ shellID: string; exitCode: number | null }> {
@@ -170,7 +178,26 @@ export const { use: useSDK, provider: SDKProvider } = createSimpleContext({
         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) => {},
+        // Called by the opencode home prompt on submit. Extract the text from
+        // the message parts, surface it as a user bubble, then stream the reply.
+        prompt: async (opts: any) => {
+          const sid: string = opts?.sessionID || (await createSession())
+          const text = ((opts?.parts ?? []) as any[])
+            .filter((p) => p && p.type === "text" && typeof p.text === "string")
+            .map((p) => p.text)
+            .join("\n")
+            .trim()
+          if (!text) return { data: undefined }
+          emitter.emit("event", { type: "user", sessionID: sid, text })
+          void streamChat(sid, text).catch((err) => {
+            emitter.emit("event", {
+              type: "error",
+              sessionID: sid,
+              error: err instanceof Error ? err.message : String(err),
+            })
+          })
+          return { data: { id: sid } }
+        },
         shell: async (opts: { sessionID?: string; command?: string; cwd?: string }) => {
           if (!opts?.command) return { data: undefined }
           const sid = opts.sessionID || (await createSession())

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

@@ -35,16 +35,45 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
       messages: Record<string, ApxMessage[]>
       currentSessionID: string | undefined
       previousMessages: Array<{ role: string; content: string }>
+      usage: { input: number; output: number }
     }>({
       status: "loading",
       sessions: [],
       messages: {},
       currentSessionID: undefined,
       previousMessages: [],
+      usage: { input: 0, output: 0 },
     })
 
     // Listen to APX stream events
     sdk.event.on("event", (ev: ApxEvent) => {
+      if (ev.type === "user") {
+        const e = ev
+        batch(() => {
+          setStore(
+            "messages",
+            produce((draft) => {
+              ;(draft[e.sessionID] ??= []).push({
+                id: `user-${Date.now()}`,
+                sessionID: e.sessionID,
+                role: "user",
+                text: e.text,
+              })
+            }),
+          )
+          setStore("previousMessages", (prev) => [...prev, { role: "user", content: e.text }])
+          setStore("currentSessionID", e.sessionID)
+          setStore(
+            "sessions",
+            produce((draft) => {
+              if (!draft.some((s) => s.id === e.sessionID)) {
+                draft.unshift({ id: e.sessionID, title: e.text.slice(0, 60) || "New session" })
+              }
+            }),
+          )
+        })
+      }
+
       if (ev.type === "chunk") {
         const e = ev
         setStore(
@@ -74,13 +103,30 @@ export const { use: useApxSync, provider: ApxSyncProvider } = createSimpleContex
           produce((draft) => {
             const msgs = (draft[e.sessionID] ??= [])
             const last = msgs[msgs.length - 1]
-            if (last?.role === "assistant") {
+            if (last?.role === "assistant" && last.streaming) {
+              // A streaming bubble already exists (chunk events arrived) — finalize it.
               last.text = e.text
               last.streaming = false
+            } else {
+              // The super-agent delivers the whole reply in `final` with no
+              // preceding chunks — create the assistant bubble here.
+              msgs.push({
+                id: `msg-${Date.now()}`,
+                sessionID: e.sessionID,
+                role: "assistant",
+                text: e.text,
+                streaming: false,
+              })
             }
           }),
         )
         setStore("previousMessages", (prev) => [...prev, { role: "assistant", content: e.text }])
+        if (e.usage) {
+          setStore("usage", (u) => ({
+            input: u.input + (e.usage?.input_tokens ?? 0),
+            output: u.output + (e.usage?.output_tokens ?? 0),
+          }))
+        }
       }
 
       if (ev.type === "shell.start") {

package/src/tui/context/sync.tsx

@@ -7,6 +7,7 @@
  */
 import { createSimpleContext } from "./helper"
 import { useApxSync } from "./sync-apx"
+import { useArgs } from "./args"
 import { onMount } from "solid-js"
 
 // Re-export useApxSync as useSync for compatibility
@@ -14,25 +15,59 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
   name: "Sync",
   init: () => {
     const apx = useApxSync()
+    const args = useArgs()
 
     onMount(() => {
       // APX sync already loads sessions in its own onMount
     })
 
+    // APX has a single configured super-agent (passed via --agent). The opencode
+    // TUI expects `data.agent` to be a non-empty list, otherwise the prompt has
+    // no "current agent" and Enter silently refuses to submit.
+    const apxAgent = () => ({
+      name: args.agent || "apx",
+      mode: "primary" as const,
+      hidden: false,
+      description: "APX super-agent",
+    })
+
+    // APX uses freeform model strings and resolves the model server-side from
+    // the CLI `--model` arg. The opencode TUI, however, refuses to submit unless
+    // `local.model.current()` resolves to a model that exists in some provider.
+    // Expose a synthetic provider containing the configured model so model
+    // resolution / validation passes. The values are cosmetic — the daemon
+    // ignores them and uses the CLI model string directly.
+    const apxModelKey = () => args.model || "apx-default"
+    const apxProvider = () => ({
+      id: "apx",
+      name: "APX",
+      models: {
+        [apxModelKey()]: {
+          id: apxModelKey(),
+          name: apxModelKey(),
+          capabilities: { reasoning: false },
+        },
+      },
+    })
+
     // 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 fields — synthetic single provider wrapping the APX model.
+        get provider() {
+          return [apxProvider()] 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[],
+        // Agent fields — APX exposes the single configured super-agent.
+        get agent() {
+          return [apxAgent()] as any[]
+        },
         command: [] as any[],
         // Session-related — delegate to APX
         get session() {