@tiens.nguyen/gu-cli 1.0.821 → 1.0.823

package/gu-relaunch.mjs

@@ -0,0 +1,35 @@
+/**
+ * `gu` without the bin path in the macOS window title (#358) — see relaunchPlan in
+ * terminal-title.mjs. gu-repl.mjs imports this FIRST, so the process is replaced before any other
+ * module has loaded or anything has been drawn.
+ */
+import { fileURLToPath } from "node:url";
+import { relaunchPlan, restoreAfterRelaunch } from "./terminal-title.mjs";
+
+export const RELAUNCHED = restoreAfterRelaunch(process);
+
+if (!RELAUNCHED) {
+  const plan = relaunchPlan({
+    platform: process.platform,
+    hasExecve: typeof process.execve === "function",
+    env: process.env,
+    argv: process.argv,
+    execPath: process.execPath,
+    script: fileURLToPath(new URL("./gu-repl.mjs", import.meta.url)),
+    stdinTTY: !!process.stdin.isTTY,
+    stdoutTTY: !!process.stdout.isTTY,
+  });
+  if (plan) {
+    // Node 23–24 flag execve as experimental; that warning would be gu's first line.
+    const emitWarning = process.emitWarning;
+    process.emitWarning = (w, ...rest) =>
+      /execve/i.test(String(w?.message ?? w)) ? undefined : emitWarning.call(process, w, ...rest);
+    try {
+      process.execve(plan.file, plan.args, plan.env); // does not return when it works
+    } catch {
+      // not allowed here (sandbox, odd node build): start the normal way, path and all
+    } finally {
+      process.emitWarning = emitWarning;
+    }
+  }
+}

package/gu-repl.mjs

@@ -23,6 +23,7 @@
  * Requires the worker daemon to be running (it claims the job).
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
+import { RELAUNCHED } from "./gu-relaunch.mjs"; // FIRST: may replace this process (#358)
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
 import { readStepTokens, readTurnCache } from "./step-tokens.mjs";
 import { snapshotInput, restoreInput, replaceStoppedQuestion, restoredQuestionLetGo, stopNoteLines } from "./turn-stop.mjs";
@@ -154,7 +155,7 @@ import {
   parseModelFallback,
 } from "./model-fallback.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
-import { TITLE_POP, TITLE_PUSH, idleTitle, needsSummary, summariseForTitle, titleSeq, trimTitle } from "./terminal-title.mjs";
+import { TITLE_POP, TITLE_PUSH, idleTitle, needsSummary, summariseForTitle, titleModel, titleSeq, trimTitle } from "./terminal-title.mjs";
 import { IMAGE_NEEDS_CLAUDE, coderTakesImagesFor, clipboardImageToFile, fitImageNotice, imageMarkersForDisplay, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
 import {
   isDoubleClick,
@@ -1633,7 +1634,17 @@ function showQuestionInTitle(question) {
   void (async () => {
     const settings = await fetchWorkerSettings();
     if (!settings || mine !== _titleSeq) return;
-    const title = await summariseForTitle(question, settings, { fetchImpl: doctorFetch });
+    // #358: the coder this turn runs on, with the key bound to its server — not the agent-model
+    // setting, which can name a model the turns never use, called with no key at all.
+    const target = titleModel(settings, { url: activeCodingUrl(), model: activeCodingModelId() });
+    if (!target) return;
+    const key = target.backendId ? await fetchKeyForBackend(target.backendId) : null;
+    if (mine !== _titleSeq) return;
+    const title = await summariseForTitle(question, settings, {
+      fetchImpl: doctorFetch,
+      target,
+      apiKey: key?.apiKey ?? "",
+    });
     if (title && mine === _titleSeq) writeTitle(title);
   })().catch(() => {});
 }
@@ -14561,3 +14572,10 @@ function releaseScreenAtExit() {
 }
 
 main();
+// Relaunched as `gu` (gu-relaunch.mjs), this file is Node's --import preload, and Node opens its
+// own REPL on the terminal once the preload finishes — so it does not finish. When nothing is
+// left to do, gu exits with its own code instead of Node's "unsettled top-level await" (13).
+if (RELAUNCHED) {
+  process.on("beforeExit", () => process.exit(process.exitCode ?? 0));
+  await new Promise(() => {});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.821",
+  "version": "1.0.823",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -116,6 +116,7 @@
     "coding-key-prompt.mjs",
     "model-fallback.mjs",
     "terminal-title.mjs",
+    "gu-relaunch.mjs",
     "server-keys.mjs",
     "add-server.mjs",
     "powershell-alias.mjs",

package/terminal-title.mjs

@@ -7,8 +7,8 @@
  * shortened, and keep it there until the next question.
  *
  * TWO STEPS, AND THE FIRST NEVER WAITS FOR THE SECOND. The trimmed question goes up the moment
- * the turn starts. Only a question too long to fit is then sent to the agent model for a
- * few-word summary, which replaces the trimmed one if — and only if — it arrives usable and the
+ * the turn starts. Only a question too long to fit is then sent to the coder the turn runs on
+ * (with its server's key — see titleModel) for a few-word summary, which replaces the trimmed one if — and only if — it arrives usable and the
  * user has not asked something else in the meantime. Every way that call can fail (no model
  * configured, a provider that wants a key this side does not hold, a timeout, a model that
  * answers with an essay) ends the same way: the trimmed question stays.
@@ -22,6 +22,8 @@
  * the bytes.
  */
 
+import { pathToFileURL } from "node:url";
+
 /** What fits on a tab next to its neighbours. Terminals clip a title; they do not wrap it. */
 export const TITLE_MAX = 60;
 
@@ -77,6 +79,56 @@ export function idleTitle(folder) {
   return name ? `gu · ${trimTitle(name, TITLE_MAX - 5)}` : "gu";
 }
 
+/**
+ * THE PATH AFTER THE TITLE (#358). macOS Terminal (and iTerm) put the running process and its
+ * arguments next to the title gu sets: `bb3d — gu · bb3d — node /opt/homebrew/Cellar/node/…/bin/gu`.
+ * The kernel builds that argv from the `#!/usr/bin/env node` line, so gu cannot change it in
+ * place — `process.title` blanks the argv area and Terminal then shows the first ENVIRONMENT
+ * variable instead (`gu TMPDIR=/var/folders/…`), and a child process shows as `gu ◂ node …`.
+ *
+ * What does work: replace the process (process.execve, Node ≥ 23.11) with node whose whole argv
+ * is `gu` and which loads this script as an --import preload. Terminal then shows `gu`. The
+ * user's flags travel in an env var, and restoreAfterRelaunch puts process.argv back the way
+ * it was, so nothing after it can tell. Node starts its own REPL once a preload finishes, so
+ * the relaunched gu-repl.mjs never finishes (see its last lines).
+ *
+ * Only for the plain interactive `gu` on macOS: a subcommand, --help/--version, a pipe (node
+ * would read a PROGRAM from a non-terminal stdin), Windows and Linux keep the old start.
+ * GU_NO_RELAUNCH=1 turns it off.
+ */
+export const RELAUNCH_ENV = "GU_RELAUNCHED";
+
+/** → { file, args, env } for process.execve, or null to start the normal way. */
+export function relaunchPlan({ platform, hasExecve, env = {}, argv = [], execPath, script, stdinTTY, stdoutTTY }) {
+  if (platform !== "darwin" || !hasExecve || !stdinTTY || !stdoutTTY || !execPath || !script) return null;
+  if (env[RELAUNCH_ENV] != null || env.GU_NO_RELAUNCH === "1") return null;
+  const args = argv.slice(2);
+  if (args.some((a) => !a.startsWith("-") || a === "--help" || a === "-h" || a === "--version")) return null;
+  const state = JSON.stringify({ script, args, nodeOptions: env.NODE_OPTIONS ?? null });
+  // A file URL has no spaces (%20) and no quotes, so it is one NODE_OPTIONS word as it stands.
+  const nodeOptions = [`--import=${pathToFileURL(script).href}`, env.NODE_OPTIONS].filter(Boolean).join(" ");
+  return { file: execPath, args: ["gu"], env: { ...env, [RELAUNCH_ENV]: state, NODE_OPTIONS: nodeOptions } };
+}
+
+/**
+ * In the relaunched process: put process.argv and NODE_OPTIONS back, and take the marker out of
+ * the environment — every process gu starts (the worker, the agent's commands) inherits it, and
+ * a NODE_OPTIONS that preloads gu-repl.mjs would start a gu inside each node they run.
+ * → true when this process is the relaunched one.
+ */
+export function restoreAfterRelaunch(proc) {
+  const raw = proc.env[RELAUNCH_ENV];
+  if (raw == null) return false;
+  delete proc.env[RELAUNCH_ENV];
+  let s;
+  try { s = JSON.parse(raw); } catch { return false; }
+  if (proc.argv.length !== 1 || !s?.script) return false; // a stale marker, not our relaunch
+  if (s.nodeOptions == null) delete proc.env.NODE_OPTIONS;
+  else proc.env.NODE_OPTIONS = s.nodeOptions;
+  proc.argv.splice(0, proc.argv.length, proc.execPath, s.script, ...(s.args ?? []));
+  return true;
+}
+
 /** Where the agent model answers chat, from a base that may or may not already end in /v1. */
 export function chatEndpoint(url) {
   const root = String(url ?? "").trim().replace(/\/+$/, "");
@@ -98,6 +150,30 @@ export function agentModelFromSettings(settings) {
   return { url, model: str(settings?.agentModelName) || "default_model" };
 }
 
+/** A server URL reduced to what identifies it: no case, no trailing slash, no trailing /v1. */
+function serverOf(url) {
+  return String(url ?? "").trim().toLowerCase().replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+
+/**
+ * WHICH MODEL WRITES THE TITLE (#358): the coder this turn runs on, and the server row its key
+ * is bound to. → { url, model, backendId } or null.
+ *
+ * It used to be the account's agent-model setting, which on a real account was OpenAI o1 —
+ * not what the turns ran on (kimi-k3 on ollama.com), and called without a key, so every long
+ * question stayed trimmed. The coder is the model the user has already chosen and keyed; the
+ * agent-model setting is only the fallback for a session whose coder is not known yet.
+ */
+export function titleModel(settings, coder = {}) {
+  const rows = Array.isArray(settings?.agentCodingBackends) ? settings.agentCodingBackends : [];
+  const rowFor = (url) => rows.find((r) => r?.id && serverOf(r.url) === serverOf(url))?.id ?? "";
+  const url = String(coder?.url ?? "").trim();
+  const model = String(coder?.model ?? "").trim();
+  if (url && model) return { url, model, backendId: rowFor(url) };
+  const agent = agentModelFromSettings(settings);
+  return agent ? { ...agent, backendId: rowFor(agent.url) } : null;
+}
+
 export function summaryRequest(model, question) {
   const q = Array.from(cleanTitleText(question)).slice(0, SUMMARY_INPUT_MAX).join("");
   return {
@@ -140,20 +216,22 @@ export function pickSummary(body, max = TITLE_MAX) {
 }
 
 /**
- * Ask the agent model for a title. → the title, or "" for every reason there is not one.
+ * Ask a model for a title. → the title, or "" for every reason there is not one.
+ * `target` ({ url, model }, see titleModel) picks the model — the agent-model setting when absent —
+ * and `apiKey` is sent as a Bearer token when the server needs one.
  * Never throws: this runs beside a turn and must not be able to disturb it.
  */
 export async function summariseForTitle(
   question,
   settings,
-  { fetchImpl = fetch, timeoutMs = 20_000 } = {},
+  { fetchImpl = fetch, timeoutMs = 20_000, target = null, apiKey = "" } = {},
 ) {
-  const agent = agentModelFromSettings(settings);
+  const agent = target?.url && target?.model ? target : agentModelFromSettings(settings);
   if (!agent || !needsSummary(question)) return "";
   try {
     const res = await fetchImpl(chatEndpoint(agent.url), {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}) },
       body: JSON.stringify(summaryRequest(agent.model, question)),
       signal: AbortSignal.timeout(timeoutMs),
     });