opencode-localhost 0.1.0 → 0.7.1

package/src/server/llamacpp/models-ini.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 import * as Ini from "../../shared/ini.ts"
-import { configDir } from "../../shared/paths.ts"
+import { configDir, expandHome } from "../../shared/paths.ts"
 import type { LocalModel } from "./discover.ts"
 
 /**
@@ -86,12 +86,29 @@ export type SyncResult = {
 export async function sync(models: LocalModel[]): Promise<SyncResult> {
   const existing = await fs.readFile(FILE, "utf8").catch(() => "")
   const doc = Ini.parse(existing)
+  // llama-server opens these paths literally — it does not expand `~`, so a
+  // hand-written `model = ~/...` fails with "failed to open GGUF file". This is
+  // the one case where an existing section is rewritten, because leaving it
+  // alone means the model silently never loads.
+  let rewrote = false
+  for (const item of doc.sections) {
+    for (const key of ["model", "mmproj"] as const) {
+      const raw = Ini.get(item, key)?.trim()
+      if (!raw || !raw.startsWith("~")) continue
+      Ini.set(item, key, expandHome(raw))
+      rewrote = true
+    }
+  }
   const names = new Set(doc.sections.map((item) => item.name))
 
+  // Compare expanded paths. Hand-written sections routinely use `~/...` while
+  // discovery always produces absolute paths; comparing the raw strings makes
+  // an already-tuned model look new, and appends a default 32k section beside
+  // it that then wins — silently replacing tuned settings.
   const byFile = new Map<string, string>()
   for (const item of doc.sections) {
     const file = Ini.get(item, "model")?.trim()
-    if (file) byFile.set(file, item.name)
+    if (file) byFile.set(expandHome(file), item.name)
   }
 
   const added: string[] = []
@@ -110,7 +127,8 @@ export async function sync(models: LocalModel[]): Promise<SyncResult> {
     added.push(section({ ...model, id }))
   }
 
-  const body = existing.trim().length > 0 ? existing.replace(/\s+$/, "") : HEADER
+  const source = rewrote ? Ini.serialize(doc) : existing
+  const body = source.trim().length > 0 ? source.replace(/\s+$/, "") : HEADER
   const next = added.length > 0 ? [body, "", added.join("\n\n"), ""].join("\n") : body + "\n"
 
   await fs.mkdir(path.dirname(FILE), { recursive: true }).catch(() => {})

package/src/shared/types.ts

@@ -21,6 +21,19 @@ export type LoadedModel = {
   loading?: boolean
   /** 0-1 while weights stream in. */
   progress?: number
+  /** Which stage is streaming, e.g. "text_model" or "mmproj". */
+  stage?: string
+}
+
+/** A model changing state, streamed while it loads. */
+export type LoadEvent = {
+  model: string
+  loading: boolean
+  loaded?: boolean
+  failed?: boolean
+  /** 0-1 for the stage named below. */
+  progress?: number
+  stage?: string
 }
 
 /**
@@ -34,18 +47,26 @@ export type ProviderStatus =
   | { state: "running"; endpoint: string; loaded?: LoadedModel }
   | { state: "failed"; message: string; hint?: string }
 
-export type PanelData = {
-  backend: { id: string; name: string }
+/** One engine. A machine can have several, each its own opencode provider. */
+export type BackendPanel = {
+  id: string
+  name: string
   status: ProviderStatus
+  loaded?: LoadedModel
+}
+
+export type PanelData = {
   /**
-   * Whether opencode has actually picked up the provider. False while the
-   * server is up but opencode has not re-read its config — the one case where
-   * a restart is genuinely required, so the panel has to say so.
+   * Only backends the user has actually configured. Listing every engine we
+   * know about would put three dead rows on screen forever; /localhost is
+   * where the full list with install state lives.
    */
+  backends: BackendPanel[]
+  /** Whether opencode has picked any of these up as providers yet. */
   registered?: boolean
+  /** Shared: one GPU pool no matter how many engines are installed. */
   gpus: GpuStat[]
   memory?: SystemStat
-  cpu?: SystemStat
   /** Tokens per second, while generating. */
   throughput?: number
 }

package/src/tui/backends.ts

@@ -0,0 +1,14 @@
+import { create as llamacpp } from "../server/llamacpp/index.ts"
+import type { Backend } from "../server/backend.ts"
+
+/**
+ * The engines this TUI half talks to, shared so the panel, the setup screen
+ * and the commands all see the same instances and the same busy state.
+ *
+ * A machine can have several; each is its own opencode provider.
+ */
+export const BACKENDS: Backend[] = [llamacpp()]
+
+export function backendById(id: string): Backend | undefined {
+  return BACKENDS.find((backend) => backend.id === id)
+}

package/src/tui/index.tsx

@@ -1,6 +1,42 @@
-import { createEffect, For, Show } from "solid-js"
+import { createEffect, createSignal, For, Show } from "solid-js"
 import { Hardware, Provider, Model, hardwareRows, usePanelData } from "./panel.tsx"
 import { openSetup } from "./setup.tsx"
+import { BACKENDS, backendById } from "./backends.ts"
+
+/**
+ * Shared so the strip, the sidebar and the command all show the same busy
+ * state — start can take twenty seconds and three views disagreeing about
+ * whether it is running looks broken.
+ */
+const [busy, setBusy] = createSignal<string | undefined>(undefined)
+
+/**
+ * opencode's own model picker, rather than a second one of ours: selecting a
+ * model is TUI-local state a plugin cannot write, so a custom list could show
+ * models but never switch to one.
+ */
+function openModelPicker(api: any) {
+  try {
+    api.keymap.dispatchCommand("model.list")
+  } catch {
+    api.ui.toast({ message: "could not open the model picker", variant: "error" })
+  }
+}
+
+async function toggleServer(id: string) {
+  if (busy()) return
+  const backend = backendById(id)
+  if (!backend) return
+  setBusy(id)
+  try {
+    const status = await backend.status()
+    await (status.state === "running" ? backend.stop() : backend.start())
+  } catch {
+    // status reflects whatever actually happened on the next poll
+  } finally {
+    setBusy(undefined)
+  }
+}
 
 /**
  * The TUI half.
@@ -15,13 +51,17 @@ import { openSetup } from "./setup.tsx"
  */
 
 /**
- * Columns are fixed and flexShrink is off. Without this the row collapses
- * under its own content in a narrow terminal and the three sections overprint
- * each other. Total is 74, matching opencode's default prompt width of 75.
+ * Hardware and provider are fixed and cannot shrink — without that the row
+ * collapses under its own content and the sections overprint each other.
+ *
+ * MODEL takes whatever is left rather than a fixed width, and wraps: model ids
+ * carry a publisher prefix ("lmstudio-community/Qwen3.6-35B-A3B-GGUF"), which a
+ * fixed column truncated at exactly the identifying part. The strip keeps the
+ * prompt's 75-column max so it stays centred with everything else on the home
+ * screen — full width made it hug the left edge while the prompt stayed centred.
  */
-const HARDWARE_WIDTH = 30
-const PROVIDER_WIDTH = 18
-const MODEL_WIDTH = 23
+const HARDWARE_WIDTH = 28
+const PROVIDER_WIDTH = 17
 
 /** One `│` per row, so the rule spans the whole block rather than its first line. */
 function Divider(props: { color: string; rows: number }) {
@@ -35,7 +75,8 @@ function Divider(props: { color: string; rows: number }) {
 
 /** opencode exposes the providers it loaded, which is how we detect the gap. */
 function registered(api: any) {
-  return () => (api.state?.provider ?? []).some((item: any) => item?.id === "llamacpp")
+  const known = new Set(BACKENDS.map((backend) => backend.id))
+  return () => (api.state?.provider ?? []).some((item: any) => known.has(item?.id))
 }
 
 /**
@@ -64,10 +105,10 @@ function requestReload(api: any): boolean {
  * Guarded because the reload is asynchronous: without it, every poll before
  * the provider list refreshes would fire another signal.
  */
-function useAutoReload(api: any, data: () => { status: { state: string }; registered?: boolean }) {
+function useAutoReload(api: any, data: () => { backends: { status: { state: string } }[]; registered?: boolean }) {
   let fired = false
   createEffect(() => {
-    const ready = data().status.state === "running"
+    const ready = data().backends.some((backend) => backend.status.state === "running")
     if (!ready || data().registered !== false) {
       // reset once opencode has caught up, so a later restart of the backend
       // can trigger exactly one more reload
@@ -90,11 +131,11 @@ function HomePanel(props: { api: any }) {
       </box>
       <Divider color={theme().border} rows={hardwareRows(data()) + 1} />
       <box width={PROVIDER_WIDTH} flexShrink={0} flexDirection="column">
-        <Provider theme={theme()} data={data()} />
+        <Provider theme={theme()} data={data()} busy={busy()} onToggle={(id) => void toggleServer(id)} />
       </box>
       <Divider color={theme().border} rows={hardwareRows(data()) + 1} />
-      <box width={MODEL_WIDTH} flexShrink={0} flexDirection="column">
-        <Model theme={theme()} data={data()} />
+      <box flexGrow={1} minWidth={20} flexDirection="column">
+        <Model theme={theme()} data={data()} onChange={() => openModelPicker(props.api)} />
       </box>
     </box>
   )
@@ -107,11 +148,9 @@ function SidebarPanel(props: { api: any }) {
     <box flexDirection="column">
       <Hardware theme={theme()} data={data()} />
       <box height={1} />
-      <Provider theme={theme()} data={data()} stacked />
+      <Provider theme={theme()} data={data()} stacked busy={busy()} onToggle={(id) => void toggleServer(id)} />
       <box height={1} />
-      <Show when={data().status.state === "running"}>
-        <Model theme={theme()} data={data()} stacked />
-      </Show>
+      <Model theme={theme()} data={data()} stacked onChange={() => openModelPicker(props.api)} />
     </box>
   )
 }
@@ -127,6 +166,19 @@ const tui = async (api: any) => {
       slash: { name: "localhost" },
       onSelect: () => openSetup(api),
     },
+    {
+      // keyboard route to the same action: tab is opencode's agent cycler, so
+      // the panel cannot be tabbed into. This is bindable and in ctrl+p.
+      title: "Local models: start/stop server",
+      value: "localhost.server.toggle",
+      category: "Provider",
+      onSelect: () => {
+        // with one engine this is unambiguous; with several the setup screen
+        // is where you pick which, so this acts on the first configured one
+        const first = BACKENDS[0]
+        if (first) void toggleServer(first.id)
+      },
+    },
   ])
 
   api.slots.register({